cuaderno docente manual para la asignatura … · externas que configuran la organización de un...

CUADERNO DOCENTE

MANUAL PARA LA ASIGNATURA COMPUTACIÓN I, FUNDAMENTOS,

PARA LOS CÓDIGOS DE ASIGNATURA CIC 2451, CCA2551 Y CIA 2551

Preparado por:

Dr. Oscar Caneo Salinas

RPI:

Septiembre 2018

Material instruccional de apoyo a una parte de los contenidos de las asignaturas

“COMPUTACIÓN I, FUNDAMENTOS para las Carreras: Ingeniería Civil Industrial CIC2451, Ingeniería Civil Ambiental CCA2551, e Ingeniería Ambiental CIA2551”

En términos específicos, este material instruccional ha sido diseñado como apoyo para aprendizaje de los siguientes contenidos de los referidos programas de asignatura:

• La Resolución de un problema, análisis, diseño del algoritmo,

• Pseudocódigo,

• Aplicaciones a problemas numéricos que contengan estructuras secuenciales y selectivas simples y dobles,

• Estructuras repetitivas, mientras, repetir y desde/para,

• Estructuras de decisión anidadas, y

• Estructuras de repetición anidadas.

Autor : Dr. Oscar Caneo Salinas

Registro de Propiedad Intelectual:

El uso y presentación de la bibliografía es de exclusiva responsabilidad del autor y/o

compilador de este material instruccional.

Fecha de Recepción:

Fecha de Recepción:

Fecha de Aprobación:

SOLO PARA USO INTERNO Y RESTRINGIDO

I

ÍNDICE DE CONTENIDOS

PROGRAMA DE LA ASIGNATURA ..................................................................................................................................... 4

INTRODUCCIÓN .......................................................................................................................................................................... 8

1. ¿QUÉ ES UN ALGORITMO?......................................................................................................................................... 11

2. METODOLOGÍA DE RESOLUCIÓN DE PROBLEMAS DE PROGRAMACIÓN.............................. 12

2.1.- Análisis del problema .................................................................................................................................................. 12

2.2.- Diseño del algoritmo. .................................................................................................................................................. 13

3. LENGUAJES PARA LA REPRESENTACIÓN DE ALGORITMOS............................................................. 15

3.1.- Diagrama de Flujo ........................................................................................................................................................ 15

3.2.- Pseudocódigo ................................................................................................................................................................. 15

4. HERRAMIENTA PARA LA ESCRITURA Y EDICIÓN DE ALGORITMOS EN

PSEUDOCÓDIGO Y EN DIAGRAMAS DE FLUJO PSeInt ........................................................................... 19

4.1.- Introducción ................................................................................................................................................................... 19

4.2.- Instalación ....................................................................................................................................................................... 20

4.3.- Entorno de PSeInt. ...................................................................................................................................................... 21

4.4.- Modo de uso de los Comandos básicos para escribir instrucciones y estructuras de control. ............. 27

5. EJEMPLOS DE PROBLEMAS RESUELTOS DE DISEÑO DE ALGORITMOS ................................... 31

5.1.- Algoritmos de estructura Secuencial ....................................................................................................................... 31

5.2.- Algoritmos de estructura Selectiva .......................................................................................................................... 33

5.2.1.- Algoritmos de estructura Selectiva Simple ........................................................................................................... 33

5.2.2.- Algoritmos de estructura Selectiva Doble ............................................................................................................ 37

5.3.- Estructuras Repetitivas ............................................................................................................................................... 43

5.3.1.- Mientras. .......................................................................................................................................................................... 43

5.3.2.- Repetir. ............................................................................................................................................................................. 50

5.3.3.- Para. .................................................................................................................................................................................. 55

6. PROBLEMAS PROPUESTOS DE DISEÑO DE ALGORITMOS ................................................................. 59

6.1.- Problemas propuestos cuyas soluciones usan estructuras Selectivas ........................................................... 59

6.2.- Problemas propuestos cuyas soluciones usan estructuras Repetitivas ......................................................... 63

Referencias ......................................................................................................................................................................................... 66

II

ÍNDICE DE FIGURAS

Figura 1:Elementos que se definen en un algoritmo .................................................................................... 11

Figura 2: DF (Diagrama de Flujo) para el problema del cálculo del volumen de un cilindro ............... 13

Figura 3: Pseudocódigo para el problema del cálculo del volumen de un cilindro ................................. 14

Figura 4: Representación de Inicio de Proceso ............................................................................................. 15

Figura 5: Representación de Fin de Proceso ................................................................................................. 16

Figura 6: Acción de Leer Datos ....................................................................................................................... 16

Figura 7: Acción de Escribir ............................................................................................................................. 16

Figura 8: Acción de Asignar ............................................................................................................................. 17

Figura 9: Estructura para el control condicional del flujo del proceso ..................................................... 17

Figura 10: Estructura de control Mientras. .................................................................................................... 18

Figura 11: Ventana del instalador de PSeInt .................................................................................................. 20

Figura 12: Elementos del Entorno de Trabajo .............................................................................................. 21

Figura 13: Acciones de la opción Archivo del Menú ................................................................................... 22

Figura 14: Acciones de la opción Archivo del Menú ................................................................................... 22

Figura 15: Acciones de la opción Configurar del Menú .............................................................................. 23

Figura 16: Acciones de la opción Ejecutar del Menú ................................................................................... 23

Figura 17: Acciones de la opción Ayuda del Menú ...................................................................................... 23

Figura 18: Acciones de la Cinta de opciones ................................................................................................. 23

Figura 19: Pestaña de Lista de Variables ........................................................................................................ 24

Figura 20: Pestaña y ventana de Operadores y Funciones .......................................................................... 24

Figura 21: Ventana de Comandos ................................................................................................................... 25

Figura 22: Uso de Comandos ........................................................................................................................... 25

Figura 23: Activación de la Ventana de Comandos ...................................................................................... 25

Figura 24: Ventana Paso a paso ....................................................................................................................... 26

Figura 25: Activación de la ventana Paso a paso .......................................................................................... 26

Figura 26: Comando Escribir ........................................................................................................................... 27

Figura 27: Comando Leer ................................................................................................................................. 27

Figura 28: Comando Asignar ............................................................................................................................ 27

Figura 29: Comando Si-Entonces .................................................................................................................... 28

Figura 30: Estructura Si-Entonces ................................................................................................................... 28

Figura 31: Ejemplo de Si-Entonces ................................................................................................................. 28

Figura 32: Ejemplo de Si-Entonces sin sino .................................................................................................. 28

Figura 33: Ejemplo de uso de operadores lógicos en Si-Entonces ............................................................ 29

Figura 34: Comando Mientras .......................................................................................................................... 29

Figura 35: Estructura Mientras ......................................................................................................................... 29

Figura 36: Ejemplo uso de operadores lógicos en Mientras ....................................................................... 29

Figura 37: Comando Repetir ............................................................................................................................ 29

Figura 38: Estructura Repetir ........................................................................................................................... 30

Figura 39: Comando Para ................................................................................................................................. 30

Figura 40: Estructura Para ................................................................................................................................ 30

Figura 41: Diagrama de flujo (DF) Suma de dos números cualquiera ...................................................... 31

Figura 42: Pseudocódigo Suma de dos números cualquiera ....................................................................... 31

Figura 43: DF cálculo de la función f(x) ......................................................................................................... 32

III

Figura 44: Pseudocódigo cálculo de la función f(x) ...................................................................................... 32

Figura 45: DF; Verifica si un valor es positivo .............................................................................................. 34

Figura 46: Pseudocódigo; Verifica si un valor es positivo ........................................................................... 34

Figura 47: DF; Suma de dos números distintos ............................................................................................ 35

Figura 48: Pseudocódigo; Suma de dos números distintos ......................................................................... 36

Figura 49: DF; Verifica si Aprueba o Reprueba ............................................................................................ 37

Figura 50: Pseudocódigo; Verifica si Aprueba o Reprueba ......................................................................... 38

Figura 51: DF; Aprobado Reprobado con verificación de nota ................................................................ 39

Figura 52: Pseudocódigo; Aprobado Reprobado con verificación ............................................................ 39

Figura 53: DF; Solución para las raíces de una ecuación de 2º grado ....................................................... 41

Figura 54: Pseudocódigo; Raíces Solución de una ecuación de 2º grado ................................................. 42

Figura 55: DF; Raíces cuadradas entre 11 y 30.............................................................................................. 44

Figura 56: Pseudocódigo; Raíces cuadradas entre 11 y 30 .......................................................................... 45

Figura 57: DF; Divisores de un entero ........................................................................................................... 46

Figura 58: Pseudocódigo; Divisores de un entero ........................................................................................ 47

Figura 59: DF Suma de los divisores de un entero ....................................................................................... 48

Figura 60: Pseudocódigo; Suma de los divisores de un entero ................................................................... 49

Figura 61: DF (1); Diferencia Mientras (A), Repetir (B) .............................................................................. 50

Figura 62: Pseudocódigo (1); Diferencia Mientras (A), Repetir (B) ........................................................... 50

Figura 63: DF; Repeticiones Mientras (A) y Repetir (B) no equivalentes ................................................. 51

Figura 64: Pseudocódigo; Repeticiones Mientras (A) y Repetir (B) no equivalentes .............................. 51

Figura 65: DF y Pseudocódigo; Raíces cuadradas entre 11 y 30 usando Repetir .................................... 52

Figura 66: DF y Pseudocódigo; Divisores de un entero usando Repetir .................................................. 53

Figura 67: DF y Pseudocódigo; Suma de los divisores de un entero usando Repetir ............................ 54

Figura 68: Pseudocódigo; Elementos de la estructura de repetición Para ................................................ 55

Figura 69: DF; Forma y elementos de la Repetición Para ........................................................................... 55

Figura 70: Funcionamiento y Elementos de la estructura repetitiva Para ................................................ 56

Figura 71: DF y Pseudocódigo; Raíces cuadradas entre 11 y 30 usando Para ......................................... 56

Figura 72: DF y Pseudocódigo; Divisores de un entero usando Para ....................................................... 57

Figura 73: DF y Pseudocódigo; Suma de los divisores de un entero usando Para ................................. 58

4

PROGRAMA DE LA ASIGNATURA

I) Identificación de la asignatura:

Nombre de asignatura: Computación I: Fundamentos, para los códigos de asignaturas: CIC2451 (Ingeniería Civil Industrial), CCA2551 (Ingeniería Civil Ambiental) y CIA2551 (Ingeniería Ambiental)

Taller / Curso: Curso

Semestre: Segundo

Número de periodos: 2

Facultad: Ciencias Naturales y Exactas

II) Descripción de la asignatura:

La finalidad del curso es brindar los conocimientos necesarios para que el alumno pueda describir e implementar la resolución de problemas mediante programación de Computadores personales.

El lenguaje que se utilizará para la resolución de problemas será Pascal, aunque se puede utilizar también otros lenguajes de cuarta generación.

III) Objetivos Generales

✓ Proporcionar los conocimientos básicos de Informática, en aspectos referidos al hardware, el software.

✓ Proporcionar los conocimientos básicos de los fundamentos de programación de computadores, en especial los referidos al diseño de algoritmos y la programación de computadores

✓ Desarrollar la habilidad de confección de algoritmos en las técnicas más usuales, diagramación y pseudocódigo, respetando las exigencias de la programación estructurada.

✓ Consolidar en los alumnos el pensamiento lógico necesario para la resolución de problemas en el contexto del paradigma procedural o programación estructurada utilizando un lenguaje estructurado.

✓ Desarrollar habilidades para realizar programas utilizando Pascal como lenguaje de programación

IV) Objetivos Específicos

✓ Reconocer y describir las características técnicas y funcionales de las componentes internas y externas que configuran la organización de un computador personal

✓ Comprender la importancia de los programas de los sistemas operativos y describir sus principales componentes a nivel funcional.

5

✓ Describir los pasos metodológicos de la resolución de problemas de programación conforme al paradigma procedural

✓ Conocer y utilizar el concepto de algoritmo y sus formas de representación para diseñar soluciones a problemas de procesamiento de datos

✓ Aplicar y manejar las estructuras algorítmicas en la resolución de problemas

✓ Conocer y utilizar los recursos de un lenguaje de programación para implementar algoritmos como programas

✓ Resolver problemas aplicando un lenguaje estructurado de programación

✓ Conocer y utilizar técnicas básicas de prueba y depuración de programas

V) Unidades Temáticas

MÓDULO I. CONCEPTOS BÁSICOS Y METODOLOGÍA PARA LA SOLUCIÓN DE

PROBLEMAS POR MEDIO DE COMPUTADORAS

Aprendizaje esperado:

✓ Describir en forma oral o escrita las características técnicas y funcionales de las componentes internas y externas que configuran la organización de un computador personal

✓ Describir en forma oral o escrita la importancia de los programas de los sistemas operativos y reconocer sus principales componentes a nivel funcional.

Contenidos:

- El Modelo de Von Newmann

- Organización de un computador

- Software

- SW de sistema

- SW de aplicación

- Lenguajes de programación

- Introducción a la resolución de problemas

- De los problemas a los programas

- ¿Qué es un algoritmo?

- Pensamiento Algorítmico

- Definición de algoritmo.

- Algoritmos cotidianos

- Definición de lenguajes algorítmicos

- Metodología para la solución de problemas por medio de computadora

- Definición del problema

- Análisis del problema

- Diseño del algoritmo

- Codificación

- Prueba y depuración

- Documentación

- Mantenimiento

6

MÓDULO II. ALGORITMOS


✓ Aplicar las habilidades básicas algorítmicas y sus formas de representación para la resolución de problemas de procesamiento de datos

✓ Resolver situaciones problemáticas utilizando las estructuras algorítmicas

Contenidos:

- Entidades primitivas para el desarrollo de Algoritmos

- Escritura de un algoritmo

- Variables Reglas para la construcción de identificadores

- Constantes

- Tipos de datos

- Contadores

- Acumuladores

- Identificadores

- Palabras reservadas

- Operadores

- Orden de evaluación de los operadores

- Expresiones.

- Técnicas para la representación de algoritmos

- Diagrama de flujo

- Pseudocódigo

- Técnicas de diseño Top down y Bottom up

- Estructuras algorítmicas

- Concepto de programación estructurada

- Estructuras Secuenciales: Asignación, Entrada y Salida

- Estructuras Condicionales: Simples, Múltiples y Anidadas

- Estructuras Repetitivas: Simples y anidadas

MÓDULO III. INTRODUCCIÓN A LA PROGRAMACIÓN


✓ Emplear los recursos de un lenguaje de programación para implementar algoritmos como programas

✓ Aplicar las habilidades básicas de la resolución de problemas en contextos que requieran la verificación y utilización de técnicas básicas de prueba y depuración de programas

Contenidos:

- Elementos de un programa en Pascal

- Identificadores,

- Palabras reservadas

- Comentarios

- Signos de puntuación y separadores

- Declaración de unidades

7

- Estructura de un programa en Pascal

- Sección de declaraciones

- Programa principal

- Tipos de datos

- Entrada y salida de datos

- Operadores

- Operadores de asignación

- Operadores aritméticos

- Operadores relacionales

- Operadores lógicos

- Expresiones

- Funciones básicas predefinidas

- Estructuras de control de selección

- Sentencia if/else

- Sentencia if/else anidadas

- Sentencias case

- Estructuras de control de repetición

- Sentencia while

- Sentencia repeat/until

- Sentencia for

MÓDULO IV ARREGLOS


✓ Emplear los recursos de un lenguaje de programación para implementar algoritmos como programas

✓ Construir programas para dar solución a problemas de contexto planteados, haciendo uso de un lenguaje de programación

Contenidos:

- Concepto de arreglo

- Declaración de arreglo unidimensional

- Operaciones con arreglos

- String: arreglos de caracteres

- Métodos de ordenamiento

- Burbuja

- Selección

- Inserción

- Métodos de búsqueda

- Secuencial

- Binaria

- Declaración de arreglos bidimensionales

- Operaciones con arreglos bidimensionales

8

INTRODUCCIÓN

La programación de computadores es considerada una disciplina científica, que es parte de las Ciencias de la computación.

Su origen está asociado con la aparición de las primeras máquinas que tenían la capacidad de ejecutar instrucciones y con capacidades para realizar cálculos numéricos y operaciones lógicas, para lo cual éstas deben ser descritas en términos de operaciones sencillas, lo que en palabras simples es la programación de computadores, y que por tanto nace de la mano con los computadores, y es consustancial al uso de los mismos, en el sentido de que para sacar provecho de los computadores, es necesaria la existencia variados software, es decir de programa que han sido diseñados y escritos para tratar con problemas generales o específicos con el apoyo de estas máquinas.

En estos términos, la programación de computadores debemos entenderla como el acto de escribir conjuntos de instrucciones, cálculos numéricos y operaciones lógicas, para automatizar la solución de un problema, utilizando algún lenguaje de programación, como Pascal, C, Java, VBasic, etc.

Así por ejemplo, podríamos usar alguno de estos lenguajes para automatizar la solución del problema

de determinar los valores de las variables 𝑥 e 𝑦 en cualquier sistema de ecuaciones de primer grado con dos incógnitas.

Sin embargo, la escritura de un programa en un lenguaje como los que señalamos constituye el paso más fácil de la programación, ya que cuando se llega a este punto, se debería haber hecho el paso previo de establecer las secuencias de instrucciones, acciones, cálculos numéricos y operaciones lógicas, que ha de considerar el programa que se va a escribir.

Si pensamos en el ejemplo anterior, previo a la escritura del programa en algún lenguaje, se debe establecer el orden de las acciones, los cálculos, etc. que son necesarias de realizar para determinar

los valores de las variables 𝑥 e 𝑦 para cualquier sistema de ecuaciones de primer grado con dos incógnitas.

Por tanto, la premisa básica y fundamental en la programación de computadores es que si se quiere indicar al computador mediante un lenguaje lo que queremos que haga, primero debemos disponer de una descripción clara, detallada y precisa de lo que queremos pedirle que realice. La descripción clara, detallada y precisa, se expresa mediante un algoritmo.

El diseño de algoritmos es entonces el aspecto más crucial e importante de la programación de computadores. Cuando un programa computacional funciona de manera incorrecta o está incompleto, casi con toda seguridad, se debe a errores o incompletitud en el diseño del algoritmo.

Ahora bien, aprender a diseñar algoritmos es una tarea de alguna forma compleja, en el sentido de que, para tener éxito en ellas, requiere que el aprendiz desarrolle lo que se denomina un aprendizaje activo, lo que significa que no sólo se han de estudiar y comprender los fundamentos del diseño de algoritmos, sino que además se debe realizar una práctica activa de aplicación de estos fundamentos, lo que se refleja en una frase típica a la que hacemos mención todos quienes llevamos varios años enseñando programación de computadores, “el camino correcto para aprender a diseñar algoritmos, es diseñándolos”. Esto significa que la práctica directa en el diseño de algoritmos es una cuestión esencial para lograr el aprendizaje. Dicho de otra forma, “nadie aprenderá a diseñar algoritmos sólo mirando como otros los resuelven o copiando algoritmos ya resueltos”.

El propósito del presente texto de estudio es aportar al aprendizaje y la compresión de los fundamentos del diseño de algoritmos, y está pensado para estudiantes que cursan una primera o quizás, única asignatura se Fundamentos de programación de computadores, o de Introducción a la

9

programación de computadores, o Programación de computadores, que son los nombres alternativos que suelen darse a estas asignaturas, dentro del currículum de muchas carreras de formación profesional. Es importante también precisar que dado que este texto es de carácter básico en estas materias, no está concebido para estudiantes de algunas de las carreras de Ingeniería relacionadas directamente con Ciencias de la Computación, ya que para ese tipo de carreras, la programación de computadores, constituye un cuerpo de conocimientos de carácter nuclear, que abarca prácticamente todo el currículum de formación profesional, contexto en el cual, un primer curso de programación, es bastante más complejos que para el caso de las carreras que no son específicamente del área de las Ciencia de la computación.

Para estos efectos, este texto de estudio se ha organizado de la siguiente manera:

En el capítulo 1 se da respuesta a la clásica pregunta ¿Qué es un algoritmo?, resaltando la importancia

que el propio concepto de Algoritmo tiene para la programación de computadores, entendiendo esta

como la herramienta para modelar soluciones a problemas de programación.

En el capítulo 2 se abordan los aspectos metodológicos de la resolución de problemas de

programación, es decir, los pasos que se deben realizar para tratar con el diseño de soluciones a

problemas de programación, enfatizando los propósitos o intencionalidades de cada paso.

En el capítulo 3 se presentan los detalles de los lenguajes para la representación de algoritmos,

particularmente, de los Diagramas de Flujo (DF) y de los Pseudocódigos, los dos lenguajes que serán

usado para los ejemplos que se muestran en el capítulo 5 de problemas resueltos de diseño de

algoritmos.

En el capítulo 4 se presentan los detalles de la herramienta para la escritura y edición de algoritmos

PSeInt, la cual es una herramienta Free para estos propósitos.

Hemos considerado la inclusión de esta herramienta, ya que consideramos conforme a nuestra

experiencia docente dictando la asignatura de Fundamentos de programación, que su uso representa

una ayuda importante, no solo para escribir los algoritmos, sino que también, para que al usar las

opciones de ejecución de algoritmos que la herramienta posee, los estudiantes tenga la posibilidad

concreta de ver y observar los detalles de cómo un cierto algoritmo es ejecutado, lo cual para nosotros,

es una contribución importante para el aprendizaje de las capacidades para el diseño de algoritmos.

Se presenta en primer término una introducción a la herramienta, luego los detalles para descargar e

instalar la herramienta, y a continuación los detalles para entender el entorno de trabajo y el modo de

uso de los comandos básicos para escribir instrucciones y estructuras de control

En el penúltimo capítulo (capitulo 5) presentamos varios ejemplos de problemas resueltos de diseño

de algoritmos, los cuales hemos organizado en función de la complejidad, en problemas que usan

estructuras secuenciales, luego ejemplos que usan estructuras selectivas tanto simples como dobles y

finalmente, estructuras repetitivas del tipo Mientras, Repetir y Para.

Finalmente, el capítulo 6 presentamos un conjunto variado de problemas propuestos organizados en

dos apartados, los que requieren del uso de estructuras Selectivas y los que requieren de estructuras

Repetitivas. La idea con estos problemas propuestos es que el estudiante disponga de un repertorio de

ejercicios para resolver, para potenciar su aprendizaje, en el bien entendido de lo que ya expresamos

en párrafos anteriores, en el sentido de que la única forma efectiva de aprender resolver problemas de

10

diseño algoritmos, es resolviéndolos y no mirando como otros los hacen, o aprendiendo de memoria

los algoritmos ya resueltos.

11

1. ¿QUÉ ES UN ALGORITMO?

Un algoritmo es la descripción clara, detallada y precisa del conjunto de instrucciones que al ser ejecutadas conducen a obtener la solución de un problema.

Así por ejemplo la expresión matemática 𝑥 =−𝑏±√𝑏2−4𝑎𝑐

2𝑎 es un algoritmo, ya que al realizar las

operaciones que en ella se indican, para un cierto conjunto de coeficientes 𝑎, 𝑏 y 𝑐 de una ecuación de

segundo grado que está escrita en la forma general 𝑎𝑥2 + 𝑏𝑥 + 𝑐 = 0, se podrá resolver el problema

de encontrar dos soluciones de la ecuación.

Desde la perspectiva computacional, un algoritmo representa un modelo de solución para un determinado tipo de problemas, y su formulación debe cumplir con el requisito de que éste debe ser independiente del lenguaje de programación que se utilice para escribirlo como un programa computacional.

Así, el diseño, construcción, y escritura de un algoritmo es el proceso más relevante de la programación de computadores. La calidad de la solución de un problema en programación, está fuertemente determinada por la calidad del algoritmo. Una solución defectuosa o incompleta para un problema, generalmente es producto de un algoritmo mal diseñado.

La construcción de un algoritmo es parte de un proceso ingenieril propio de las ciencias de la computación, que se denomina Metodología de resolución de problemas de programación.

Para cumplir con sus propósitos un algoritmo debe poseer las siguientes características

fundamentales:

✓ Debe ser preciso e indicar el orden de realización de cada paso.

✓ Debe describir acciones elementales, si una acción no puede ejecutarse de forma simple, debe ser descompuesta.

✓ Debe ser finito, el algoritmo debe terminar en algún momento; o sea, debe tener un número finito de pasos.

✓ Debe expresarse en un lenguaje estandarizado, dos o más personas que entienden el lenguaje estandarizado, deben interpretar el algoritmo de la misma forma.

✓ El resultado que produce al ser ejecutado debe ser previsible. Si se ejecuta el algoritmo dos o más veces, se debe obtener el mismo resultado cada vez.

Cualquier algoritmo debe definir tres elementos:

1. Entrada, información o datos que se requieren para ejecutar el Proceso

2. Proceso, el conjunto de acciones que deben ejecutarse para convertir la información o datos de entrada en la Salida, y

3. Salida, lo que resultan de la ejecución del Proceso

En la siguiente figura se muestran esquemáticamente estos elementos:

Figura 1: Elementos que se definen en un algoritmo

ENTRADA SALIDA

12

2. METODOLOGÍA DE RESOLUCIÓN DE PROBLEMAS DE PROGRAMACIÓN

La metodología consta de un conjunto de fases que se deben realizar al momento de solucionar un problema mediante el computador.

Estas fases son:

1.- Análisis del problema.

2.- Diseño del algoritmo.

3.- Codificación en un Lenguaje de Programación.

4.- Compilación y ejecución.

5.- Verificación y depuración.

6.- Documentación.

Teniendo en cuenta los propósitos de este apunte, trataremos en profundidad sólo las primeras dos fases, Análisis del problema y Diseño del algoritmo.

2.1.- Análisis del problema

Esta fase se desarrolla con el propósito de comprender el problema y saber exactamente qué es lo que se desea obtener como resultado.

Dado un problema, el desarrollo de esta fase se puede orientar dando respuesta a las siguientes preguntas:

Pregunta 1: ¿Cuál es el problema que se ha de resolver?

Pregunta 2: ¿Cuál o cuáles son los resultados que debe producir la solución?

Pregunta 3: ¿De qué información se dispone para resolver el problema?

Pregunta 4: ¿Cuál o cuáles son las restricciones o condiciones que debe satisfacer la solución?

Es importante precisar que, aunque la Pregunta 1 pudiera considerarse innecesaria, pueden ocurrir situaciones en que se esté intentando resolver un problema que esta fuera del alcance de los conocimientos que el resolutor posee, en cuyo caso, será imposible tener éxito en la tarea de diseñar una solución.

Para ejemplificar, el desarrollo de esta fase, supongamos que se quiere resolver el problema de determinar el volumen de un cilindro cualquiera, a partir del radio de la base y la altura de este. Las respuestas a las preguntas anteriores podrían ser:

Respuesta a la pregunta 1: Se trata con el problema de calcular el volumen de un cilindro cualquiera.

Respuesta a la pregunta 2: El resultado que debe producir la solución es el valor del volumen de

un cilindro en particular.

Respuesta a la pregunta 3: En el enunciado del problema no se expresa información, pero como se quiere calcular el volumen de un cilindro cualquiera, se requiere conocer el radio o el diámetro de la base del cilindro, y la altura de este.

13

Respuesta a la pregunta 4: Dadas las características del problema, los valores de radio o diámetro de la base y el valor de la altura que se usen para calcular el volumen deben ser positivos.

2.2.- Diseño del algoritmo.

Clarificado lo anterior, corresponde ahora diseñar el algoritmo de solución, en otras palabras, se debe pensar en el proceso y las acciones que este debe contener, para conseguir la solución al problema.

Una primera aproximación a la secuencia de acciones que deberían realizarse para resolver el problema podría ser:

i. Leer radio ii. Leer altura

iii. Verificar que los valores de radio y altura sean positivos iv. Calcular volumen v. Escribir el resultado

A partir de esta secuencia de acciones, el paso siguiente es construir el algoritmo, para lo cual se debe usar un lenguaje específico y apropiado para ello.

Para este propósito, existen varios lenguajes algorítmicos, en nuestro caso haremos referencias a dos de ellos que son, los Diagramas de flujo DF y los pseudocódigos.

En las páginas siguientes abordamos los detalles de estos dos lenguajes para la construcción de algoritmos, sin embargo, aunque más adelante trataremos con el uso de estos lenguajes, cuando se resuelven problemas concretos, nos permitimos en este punto, anticipar las construcciones algorítmicas en DF y pseudocódigo para el problema que hemos venido tratando, las que mostramos en las imágenes siguientes.

Figura 2: DF (Diagrama de Flujo) para el problema del cálculo del volumen de un cilindro

DF

14

Figura 3: Pseudocódigo para el problema del cálculo del volumen de un cilindro

SEUDOGÓDIGO

15

3. LENGUAJES PARA LA REPRESENTACIÓN DE ALGORITMOS

La representación de algoritmos se realiza usando lenguajes específicos para tal propósito, como los que se muestran en las figuras 2 y 3. Los lenguajes que usaremos en este apunte son los Diagramas de Flujo y los Pseudocódigos.

3.1.- Diagrama de Flujo

Un Diagrama de Flujo es un lenguaje para la representación gráfica de un proceso, en el cual cada paso o acción de este, es representado mediante un símbolo particular, y además utiliza líneas con flechas para conectar los símbolos gráficos y expresar la secuencia y orden en que los pasos o acciones del proceso se irán ejecutando.

Así con estos recursos visuales el Diagrama de Flujo muestra una descripción gráfica de las actividades implicadas en un proceso, evidenciando la relación secuencial ente ellas, facilitando la rápida comprensión de cada actividad y su relación con las demás, y el flujo de la información, así como la forma en que se van tratando los datos de entrada hasta producir los datos de salida.

Dado su carácter gráfico, un Diagrama de flujo facilita la visualización de los detalles de las acciones que se ejecutan dentro de un proceso.

3.2.- Pseudocódigo

El Pseudocódigo (“casi código”) es un lenguaje para la representación de algoritmos que utiliza palabras claves muy parecidas a las instrucciones o sentencias de un lenguaje de programación de computadores, por tanto, a diferencia de un Diagrama de Flujo, no utiliza símbolos gráficos conectados mediante flechas.

Por ser un lenguaje para la representación de algoritmos que se asemeja a los lenguajes de programación, genera la facilidad de que es una forma de representación que facilita la conversión del algoritmo a un lenguaje de programación de computadores.

Lógicamente, existe una equivalencia entre el lenguaje de representación de algoritmos basado en Diagrama de flujo y el basado en Pseudocódigo.

A continuación, se presentan los símbolos gráficos de Diagramas de flujo y su equivalencia en el lenguaje de Pseudocódigos que utilizaremos en este apunte.

Figura 4: Representación de Inicio de Proceso

Inicio del Proceso. Todo proceso se inicia asignándole un nombre único al mismo.

En Diagrama de flujo

En Pseudocódigo

16

Figura 5: Representación de Fin de Proceso

Figura 6: Acción de Leer Datos

Figura 7: Acción de Escribir

Fin del Proceso.

En Diagrama de flujo En Pseudocódigo

Leer datos. Esta es la acción para ingresar datos al proceso. Se pueden Leer varios datos identificándolos con nombres de variables único y separándolos por comas (,)


En Pseudocódigo

Acción de Escribir. Esta puede usarse para escribir valores de variables, resultados de expresiones matemáticas y contenidos textuales. Cada elemento a escribir debe separase por una coma (,)

Los contenidos textuales se declaran entre apostrofes en los Diagramas de flujo y entre comillas en los Pseudocódigos


17

Figura 8: Acción de Asignar

Figura 9: Estructura para el control condicional del flujo del proceso

Acción de Asignar a una variable el resultado de evaluar una expresión. La variable a la que

se asigna está a la izquierda, y la expresión está a la derecha del signo de asignación.

Esta acción puede usarse también para asignar una variable a otra.


Estructura para el control condicional del flujo del Proceso, Si la comparación lógica es verdadera, el proceso continúa con las acciones de la variante de la derecha (V), por el contrario si la comparación lógica es falsa, el proceso continua con las acciones de la variante de la izquierda (F).

También es posible una estructura de control de flujo del Proceso conocida como condicional simple, ya que en ella sólo se indican las acciones que se ejecutaran si la comparación lógica es verdadera.


18

Figura 10: Estructura de control Mientras.

Estructura de control de flujo del Proceso para hacer que se ejecuten acciones si una cierta

condición es verdadera (V). Si la condición es falsa (F), las acciones dejan de ejecutarse.

Esta estructura de control se conoce como estructura Mientras ya que las acciones se

ejecutarán Mientras la condición sea verdadera (V), en caso contrario, dejarán de ejecutarse.


En Pseudocódigo

19

4. HERRAMIENTA PARA LA ESCRITURA Y EDICIÓN DE

ALGORITMOS EN PSEUDOCÓDIGO Y EN DIAGRAMAS DE

FLUJO PSeInt

4.1.- Introducción

El programa conocido como PSeInt, debe su nombre a la contracción PSeudocode Interpreter, (Intérprete de Pseudocódigo), y en su primera versión, fue el resultado del trabajo de proyecto final de la asignatura Programación 1, del estudiante Pablo Novara de la carrera Ingeniería en Informática de la Facultad de Ingeniería y Ciencias Hídricas de la Universidad Nacional del Litoral.

Según su autor, el principal propósito de la aplicación es ayudar al aprendizaje de diseño de algoritmos. Con los apoyos que brinda la herramienta, así, el aprendiz podrá poner sus esfuerzos intelectuales principalmente en los aspectos lógicos de la solución, en las acciones, la secuenciación de ellas como procesos, y en los aspectos referidos a la organización de estas como estructura de programación. En su versión actual, es un software de licencia GLP (General Public License)

Dentro de sus principales características podemos destacar:

• Es un software libre de licencia GPL y gratuito,

• Mutiplataforma, existen versiones para instalación en sistemas operativos Microsoft Windows de 32 y 64 bits, Mac OS i686 y Mac PowerPC, GNU/Linux de 32 y 64 bits

• Permite la definición de perfiles para adaptar los lenguajes de pseudocódigos y de diagrama de flujos diferentes estilos y sintaxis.

• La escritura de los algoritmos se puede hacer directamente como sentencias en pseudocódigo, o utilizando elementos de la ventana de comandos que representan las sentencias usando símbolos del lenguaje de diagramas de flujo.

• Para la escritura de los pseudocódigos se dispone de facilidades de: autocompletado; ayudas emergentes; plantillas de comandos; coloreado de sintaxis; resaltado de bloques lógicos; indentado inteligente; y listado de funciones, operadores y variables de uso común en programación.

• Permite generar y editar el diagrama de flujo a partir del pseudocódigo, con la opción de grabarlo como archivo de imagen.

• Permite la edición simultánea de múltiples algoritmos.

• Puede interpretar (ejecutar) los algoritmos escritos, contando con facilidades para: modificar el algoritmo y ver los cambios en la ejecución inmediatamente (sin reingresar los datos); modificar uno o más datos seleccionados de una ejecución ya finalizada para observar cómo varían los resultados; deshacer una ejecución para reiniciarla o repetirla desde un punto arbitrario; ejecutar el algoritmo paso a paso controlando la velocidad e inspeccionando variables y expresiones; confeccionar automáticamente una tabla de prueba de escritorio; y un modo especial en el que describe las acciones realizadas en cada paso.

• Determina y marca claramente los errores señalando: errores de sintaxis en tiempo real (mientras escribe); errores en tiempo de ejecución; y ofrece descripciones detalladas de cada error, con sus causas y soluciones más frecuente.

http://fich.unl.edu.ar/

20

• Permite convertir el algoritmo de pseudocódigo a código en variados lenguajes de programación tales como: C, C++, C#, Java, JavaScript, MatLab, Pascal, PHP, Python 2, Python 3, QBasic Visual Basic

4.2.- Instalación

El software puede ser descargado desde http://pseint.sourceforge.net/

Luego de bajar y ejecutar el instalador, se abrirá la siguiente ventana:

Figura 11: Ventana del instalador de PSeInt

Luego, el asistente del instalador le guiará hasta completar la instalación del programa.

http://pseint.sourceforge.net/



21

4.3.- Entorno de PSeInt.

En la ventana de la aplicación se pueden identificar los siguientes elementos:

Comandos

Área de trabajo

Listado de funciones y variables Paso a paso

Cinta de opciones

Pestañas de trabajo

Menú

Figura 12: Elementos del Entorno de Trabajo

22

Figura 13: Acciones de la opción Archivo del Menú

Figura 14: Acciones de la opción Archivo del Menú

Contiene las opciones de Menú para acceder a las siguientes acciones: Menú

23

Figura 15: Acciones de la opción Configurar del Menú

Figura 16: Acciones de la opción Ejecutar del Menú

Figura 17: Acciones de la opción Ayuda del Menú

En tanto desde la Cinta de opciones se tiene acceso de forma directa a las siguientes acciones:

Figura 18: Acciones de la Cinta de opciones

Nuevo Guardar

Abrir Guardar Como…

Deshacer

Rehacer

Cortar

Copiar

Pegar

Corregir Indentado

Buscar

Buscar Anterior

Buscar Siguiente

Ejecutar…

Ejecutar paso a paso…

Dibujar Diagrama de Flujo…

Ayuda…

Cinta de opciones

24

Corresponde a la zona dónde se escribe el Pseudocódigo del algoritmo.

El Pseudocódigo se puede escribir directamente, o escogiendo el comando correspondiente desde la ventana de comandos.

A la izquierda de cada línea de pseudocódigo se muestra un número entero positivo que es el identificador de la línea, cuya referencia se utiliza cuando se indican los errores.

Cada pseudocódigo nuevo o abierto se muestra en una pestaña diferente. Si se asigna un nombre al algoritmo, este se mostrará en

la pestaña correspondiente, en caso contrario se muestra con el nombre

Corresponde a la zona vertical que se muestra en el borde izquierdo del

Esta zona está compuesta por dos pestañas que mostramos en posición horizontal en las siguientes imágenes:

Figura 19: Pestaña de Lista de Variables

Figura 20: Pestaña y ventana de Operadores y Funciones

Al activar la pestaña superior Lista de Variables, se abre una ventana que muestra un listado de las variables, según el orden en que aparecen en el Pseudocódigo.

Al activar la pestaña de Operadores y Funciones, se abre una ventana que muestra la lista ordenada por categorías y dentro de cada categoría, , los operadores y funciones que se pueden utilizar como parte del pseudocódigo.

Área de trabajo

Pestañas de trabajo

Listado de funciones y variables Área de trabajo

25

Figura 21: Ventana de Comandos

Figura 22: Uso de Comandos

Figura 23: Activación de la Ventana de Comandos

Comandos En esta ventana están disponibles como botones, los distintos comandos de

sentencias y estructuras de control, expresados en lenguaje de Diagrama de flujo (DF).

Al hacer doble clic sobre uno de los botones de la ventana de Comandos, se agrega en lenguaje

de Pseudocódigo, la sentencia o estructura de control correspondiente, en la línea de edición

que se encuentre activa en la Área de trabajo

Si la ventana de Comandos no está visible, puede hacer clic sobre la pestaña superior que se

encuentra a la derecha del Área de trabajo

26

Figura 24: Ventana Paso a paso

Figura 25: Activación de la ventana Paso a paso

En esta venta se tiene acceso a las opciones para el control de la ejecución Paso a paso.

Paso a paso

Si la ventana Paso a paso no está visible, puede hacer clic sobre la pestaña superior que se encuentra a la derecha del Área de trabajo

27

4.4.- Modo de uso de los Comandos básicos para escribir instrucciones y estructuras de

control.

Teniendo en consideración que el propósito fundamental de este manual, es ser un apoyo para el aprendizaje del diseño de algoritmos de los estudiantes de un primer curso de programación, sumado a ello la creencia de que el uso de esta aplicación les será de utilidad para el aprendizaje. A continuación, se muestran los aspectos generales de la escritura y significancia de los comandos de instrucciones y estructuras de control.

Este comando refiere a la sentencia para escribir. La acción de escribir puede hacerse respecto de un contenido textual, o una variable, o una expresión, o combinaciones de estos elementos.

Al hacer doble clic sobre este comando, en el área de trabajo se mostrará el equivalente en pseudocódigo de esta sentencia, la que corresponde a:

donde puede ser alguna de las siguientes:

• Un contenido textual, para lo cual el contenido debe ponerse entre comilla quedando como:

• El valor de una variable y/o expresión como:

En este ejemplo, se quiere escribir el valor de una cierta variable a y el resultado de sumar el valor

de la misma variable a más otra cierta variable b. Notar que cada elemento a escribir se separa por

una coma (,)

• En el siguiente ejemplo se quiere escribir un contenido textual y luego el valor de una cierta

variable a

Este comando refiere a la sentencia para leer. Las acciones de lectura se realizar para ingresar valores de variables (datos) durante la ejecución del algoritmo.


puede contener una o más variables separadas por coma (,)

Mediante este comando se declara la acción de Asignar a una variable (la que

se encuentra al lado izquierdo de ←) el contenido de otra variable o el

resultado de una expresión (que se encuentra a lado derecho de ←)

Figura 26: Comando Escribir

Figura 27: Comando Leer

Figura 28: Comando Asignar

28


Ejemplos de la forma que puede esta sentencia, son:

Este comando permite incorporar en el algoritmo a una estructura de control mediante la cual, se define que sentencia o conjunto de

sentencias se ejecutarán si una cierta expresión_lógica es

VERDADERA y que sentencias o conjunto de ellas se ejecutaran

si la misma expresión_lógica es FALSA.

Al hacer doble clic sobre este comando, en el área de trabajo se mostrará el equivalente en pseudocódigo de esta estructura de control, la que corresponde a:

Un ejemplo de uso de esta estructura podría ser:

De ser necesario, esta estructura también puede ser usada en su versión simplificada como:

para lo cual se deben eliminar las líneas correspondientes al y las siguientes, hasta la anterior al

Figura 29: Comando Si-Entonces

Figura 30: Estructura Si-Entonces

Figura 31: Ejemplo de Si-Entonces

Figura 32: Ejemplo de Si-Entonces sin sino

29

la pueden usarse operadores lógicos tales como & ó Y (Conjunción), En

| ó O (Disyunción), ∼ ó NO (Negación).

Ejemplo:

Este comando incorpora en el algoritmo, la estructura de control

Mientras para repetir una sentencia o conjuntos de sentencias.

Al hacer doble clic sobre el comando, a partir de la línea correspondiente del pseudocódigo se agregará la estructura:

Al igual que en el caso de la estructura de control Si-Entonces anterior, la

puede contener una comparación simple de la forma a<7, o usar los

operadores lógicos & ó Y, | ó O, ∼ ó NO.

Ejemplo:

Este comando incorpora en el algoritmo, la estructura de control

Repetir la que corresponde a otra estructura para repetir una sentencia

o conjuntos de sentencias.

Figura 34: Comando Mientras

Figura 35: Estructura Mientras

Figura 37: Comando Repetir

Figura 36: Ejemplo uso de operadores lógicos en Mientras

Figura 33: Ejemplo de uso de operadores lógicos en Si-Entonces

30


Figura 38: Estructura Repetir

Al igual que en los casos anteriores, la puede utilizar una expresión lógica simple u operadores lógicos

Este es el comando para la tercera forma de incorpora una estructura para repetir una sentencia o conjuntos de sentencias, dentro de un algoritmo


Figura 40: Estructura Para

Figura 39: Comando Para

31

5. EJEMPLOS DE PROBLEMAS RESUELTOS DE DISEÑO DE ALGORITMOS

5.1.- Algoritmos de estructura Secuencial

Un algoritmo de estructura secuencial tiene la característica de que, al ser ejecutado, siempre ejecutará las acciones en el mismo orden (secuencia).

Ejemplo 1:

Diseñe un algoritmo representándolo en DF y en pseudocódigo que calcule y muestre la suma de dos números cualquiera.

Análisis problema

- Datos de entrada: Por tratarse de números cualquiera, se deben ingresar los dos números.

- Datos de salida: El resultado de la suma de los dos números.

- Restricciones: No existen restricciones ya que pueden ser números cualesquiera.

- Proceso: Calcular la suma de dos números ingresados.

Diseño de la solución

- Ingreso de dos números.

- Suma de los dos números.

- Mostrar el resultado de la suma.

Representación en Diagrama de Flujo (DF)

Figura 41: Diagrama de flujo (DF) Suma de dos números cualquiera

Representación en Pseudocódigo

Figura 42: Pseudocódigo Suma de dos números cualquiera

32

Ejemplo 2:

Diseñe un algoritmo representándolo en DF y pseudocódigo para calcular y mostrar el valor la

función 𝑓(𝑥) = 3𝑥 + 2 para un valor cualquiera

Análisis problema

- Datos de entrada: Un valor cualquiera para 𝑥

- Datos de salida: El resultado del valor de la función 𝑓(𝑥) para el 𝑥 ingresado.

- Restricciones: No existen restricciones.

- Proceso: Calcular el valor de la función 𝑓(𝑥)para el valor de 𝑥 ingresado.


- Ingreso de un valor.

- Calcular el valor de la función.

- Mostrar el valor calculado para la función.

Representación en DF

Figura 43: DF cálculo de la función f(x)


Figura 44: Pseudocódigo cálculo de la función f(x)

33

5.2.- Algoritmos de estructura Selectiva

Este tipo de estructuras algorítmicas son utilizadas cuando se requiere que el proceso o parte de él, no tiene una única secuencia. El proceso que no es secuencial o la parte del proceso que no lo es, es controlada por una condición lógica.

Por tanto, se evalúan una condición y en función del resultado de esta se realiza una opción u otra. Las condiciones se especifican usando expresiones lógicas.

Existen dos casos generales de este tipo de estructuras selectivas, las de tipo selectivas simples y las del tipo selectivas dobles.

5.2.1.- Algoritmos de estructura Selectiva Simple

Las estructuras Selectivas Simples están compuesta por una condición lógica, la que al ser verdadera, continuará con la ejecución de una o más acciones, si por el contrario, la condición es falsa no hará nada.

Ejemplo 3:

Diseñe un algoritmo representándolo en DF y Pseudocódigo para mostrar un mensaje si un cierto valor es positivo.

Análisis problema

- Datos de entrada: Un valor cualquiera

- Datos de salida: Mostrar un mensaje si el valor es positivo.

- Proceso: Determinar si el valor es positivo.


- Ingreso de un valor.

- Determinar si el valor es positivo.

- Mostrar el mensaje si es positivo.

34


Figura 45: DF; Verifica si un valor es positivo

Comentario: Observe en el DF (figura 37) que mediante una condición lógica se evalúa si el valor leído es positivo. Si la condición lógica resulta ser verdadera (V) el proceso continúa por la variante de la derecha, y luego el proceso completo finaliza, por el contrario, si la condición lógica resulta ser falsa (F) el proceso continúa por la variante de la izquierda, con lo cual el mismo finaliza.


Figura 46: Pseudocódigo; Verifica si un valor es positivo

Comentario: Observe en el Pseudocódigo (figura 38) que mediante una condición lógica

(línea 3), se evalúa si el valor leído es positivo. Si la condición lógica resulta ser verdadera el

proceso continúa en la línea 4, luego la condición termina en la línea 5, y finaliza el proceso

en la línea 6. Por el contrario, si la condición lógica resulta ser falsa el proceso finaliza (línea

6).

35

Ejemplo 4:

Diseñe un algoritmo representándolo en DF y Pseudocódigo para calcular y mostrar la suma de dos números cualquiera, solo si estos son distintos.

Análisis problema

- Datos de entrada: Dos números cualquiera.

- Datos de salida: Mostrar el resultado de la suma de los dos números.

- Proceso: Determinar si los números son distintos, y sumarlos si es el caso.


- Ingreso de dos números cualquiera.

- Determinar si los números son distintos, y sumarlos si es el caso.

- Mostrar el resultado de la suma de los dos números.


Figura 47: DF; Suma de dos números distintos

Comentario: Observe en el DF (figura 47) que mediante una condición lógica se evalúa si los

números ingresados son distintos. Si la condición lógica resulta ser verdadera (V) el proceso

continúa por la variante de la derecha, con lo cual se suman los dos números y se muestra el

resultado, luego el proceso completo finaliza. Por el contrario, si la condición lógica resulta

ser falsa (F) el proceso continúa por la variante de la izquierda, y finaliza.

36


Figura 48: Pseudocódigo; Suma de dos números distintos

Comentario: Observe en el Pseudocódigo (figura 48) que mediante la condición lógica (línea

3), se evalúa si los números ingresados son distintos. Si la condición lógica resulta ser

verdadera el proceso continúa en las líneas 4 y 5, con lo cual se suman los dos números y se

muestra el resultado respectivamente, para luego el proceso completo finalizar. Por el

contrario, si la condición lógica resulta ser falsa el proceso continúa en la línea 7 finalizando.

Para verificar si los números son distintos (línea 3), se usó el operador lógico <>, pero también

es posible usar el operador lógico != que es equivalente.

37

5.2.2.- Algoritmos de estructura Selectiva Doble

Las estructuras Selectivas Dobles están compuesta por una condición lógica, la que sí es verdadera ejecutara una acción o acciones, pero si es falsa, ejecutará una acción o acciones diferentes.

Ejemplo 5:

Diseñe un algoritmo representándolo en DF y Pseudocódigo para mostrar el mensaje APROBADO si la nota final de un estudiante es mayor o igual que 4,0, y el mensaje REPROBADO en caso contrario.

Análisis problema

- Datos de entrada: La nota final de un estudiante

- Datos de salida: El mensaje APROBADO o REPROBADO según corresponda.

- Proceso: Determinar si la nota final ingresada es igual o mayor que 4,0 en cuyo caso se

muestra el mensaje APROBADO, en caso contrario, se muestra el mensaje REPROBADO.


- Ingreso de una nota.

- Determinar si el valor es mayor o igual que 4,0, de ser así se muestra el mensaje APROBADO, en caso contrario de muestra el mensaje REPROBADO


Figura 49: DF; Verifica si Aprueba o Reprueba

Comentario: Observe en el DF (figura 49) que mediante la condición lógica se evalúa si el

valor de 𝑛𝑓 leído es mayor o igual que 4,0. Si la condición lógica resulta ser verdadera (V) el

proceso continúa por la variante de la derecha, escribiendo el mensaje APROBADO, luego el

proceso completo finaliza. Por el contrario, si la condición lógica resulta ser falsa (F) el

proceso continúa por la variante de la izquierda, escribiendo el mensaje REPROBADO, y

luego el proceso completo finaliza. En consecuencia, existen acciones distintas para cada

resultado de la condición lógica.

38


Figura 50: Pseudocódigo; Verifica si Aprueba o Reprueba

Comentario: Observe en el Pseudocódigo de la figura 50 que si el valor de 𝑛𝑓 es mayor o

igual que 4,0 (línea 3), se realiza la acción de escribir APROBADO (línea 4), luego de lo cual

el proceso finaliza (línea 8). Por el contrario, si la condición lógica resulta ser falsa el proceso

continuará en el SiNo (línea 5) por lo que se escribirá REPROBADO (línea 6), y luego el

proceso finaliza (línea 8).

Ejemplo 6:

Este ejemplo es una variante del anterior (Ejemplo 5) dónde se quiere resolver el mismo caso,

pero considerando que el valor de 𝑛𝑓 debe cumplir con el requisito de ser una nota que se encuentre en el rango 1,0 a 7,0. Esta exigencia constituye una restricción que debe cumplir la solución.

Análisis problema

- Datos de entrada: La nota final de un estudiante

- Datos de salida: El mensaje APROBADO o REPROBADO según corresponda.

- Proceso: Determinar si la nota final ingresada es igual o mayor que 4,0 en cuyo caso se muestra el mensaje APROBADO, en caso contrario, se muestra el mensaje REPROBADO.

- Restricción: La nota final ingresada debe estar en el rango 1,0 a 7,0, de no ser así el algoritmo mostrará un mensaje apropiado, y no mostrará el mensaje APROBADO ni REPROBADO.


- Ingreso de una nota.

- Verificar si la nota ingresada está en el rango 1,0 a 7,0 de ser así continúa con el paso siguiente,

en caso contrario, muestra un mensaje apropiado y finaliza.

- Determinar si el valor es mayor o igual que 4,0, de ser así se muestra el mensaje APROBADO, en caso contrario de muestra el mensaje REPROBADO

39


Figura 51: DF; Aprobado Reprobado con verificación de nota

Comentario: Observe en el DF anterior que en la primera condición cuyo propósito es

verificar si el 𝑛𝑓 leído está en el rango 1.0 a 7.0, se está usando el conector lógico Y para

asegurar que, si la condición lógica es verdadera, es porque se han cumplido las dos

condiciones. Por cuestiones de más claridad en la sintaxis se aconseja que cada condición

lógica se escriba entre paréntesis ().


Figura 52: Pseudocódigo; Aprobado Reprobado con verificación

Comentario: En la línea 3 del Pseudocódigo de la figura 52 se realiza la verificación para

saber si la nota 𝑛𝑓 está en el rango 1,0 a 7,0. Si esto es cierto, se evalúa si la misma es mayor

o igual que 4,0 en cuyo caso se escribe ‘APROBADO’, luego de lo cual el proceso continuaría

en la línea 12 finalizando. Por el contrario, si 𝑛𝑓 no cumple esta última condición anterior, se

escribe ‘REPROBADO’ luego de lo cual el proceso continuaría también en la línea 12

finalizando.

Por otra parte, si la condición lógica de la línea 3 resulta ser falsa, el proceso continuará en la línea 9 para escribir el mensaje ‘La nota ingresada no está en el rango 1,0 a 7,0’ luego de lo cual el proceso finalizará en la línea 12.

40

Ejemplo 7:

Diseñe un algoritmo representándolo en DF y Pseudocódigo que determine y muestre las raíces

que son solución de una ecuación de segundo grado escrita de la forma 𝑎𝑥2 + 𝑏𝑥 + 𝑐 = 0. El

algoritmo debe ser capaz de tratar con ecuaciones de soluciones imaginarias.

Análisis problema

- Datos de entrada: Los coeficientes 𝑎, 𝑏 y 𝑐

- Datos de salida: Las soluciones de la ecuación indicando si son imaginarias, si es el caso.

Eventualmente la salida podría ser el mensaje EL COEFICIENTE 𝑎 no puede ser cero, para el caso que corresponda.

- Proceso: Verificar que el coeficiente 𝑎 sea distinto de cero, de ser así, determinar el argumento de la raíz y verificar que es cero o positivo, en cuyo caso calcular y mostrar las soluciones de la ecuación. Si el argumento de la raíz es negativo, obtener su valor absoluto y calcular y mostrar las soluciones de la ecuación indicando que las soluciones son imaginarias.

- Si el coeficiente 𝑎es cero mostrar el mensaje correspondiente.

- Restricción: El coeficiente 𝑎 no puede ser cero para el caso de una ecuación de este tipo.


- Ingreso de los coeficientes.

- Verificar si el coeficiente 𝑎 es distinto de cero, de ser así, determinar el argumento de la raíz y verificar que es cero o positivo, en cuyo caso calcular y mostrar las soluciones de la ecuación, para luego finalizar. Si el argumento de la raíz es negativo, obtener su valor absoluto y calcular y mostrar las soluciones de la ecuación indicando que las soluciones son imaginarias, y finalizar

- Si el coeficiente 𝑎es cero mostrar el mensaje correspondiente y finalizar.

41


Figura 53: DF; Solución para las raíces de una ecuación de 2º grado

Comentario: Después de leer los coeficientes 𝑎, 𝑏, 𝑐 se verifica que 𝑎 sea distinto de cero.

De ser así, el proceso continúa por la variante de la derecha y se determina el valor del

argumento de la raíz de la fórmula para resolver este tipo de ecuaciones. A continuación de

esto, se verifica que el valor del argumento de la raíz sea positivo o cero, en cuyo caso, el

proceso sigue por la variante de la derecha (V) con la determinación de las dos soluciones

𝑥1, 𝑥2 para luego escribir los valores de las soluciones y finalizar el proceso. Se usa la función

𝑟𝑐() para obtener la raíz cuadrada de 𝑟

Por el contrario, si se verifica que el valor del argumento de la raíz no es positivo, el proceso

continúa por la izquierda (F), convirtiendo 𝑟 a su valor absoluto mediante la aplicación de la

función 𝑎𝑏𝑠() y determinando los valores de las soluciones con el valor de 𝑟 convertido a

positivo, y luego escribiendo sus valores junto con el mensaje ‘Son soluciones imaginarias’

Por último, si la condición para verificación del valor 𝑎 resulta ser falsa (F), el proceso

continuará por la izquierda, con lo cual se escribirá el mensaje ‘Error en el valor de a’ y el

proceso finalizará.

42


Figura 54: Pseudocódigo; Raíces Solución de una ecuación de 2º grado

Comentario: Como se observa en la figura anterior (figura 54), en la línea 3 se verifica que 𝑎

sea distinto de cero. De ser así, el proceso continúa en la línea 4 con la determinación del valor

del argumento de la raíz. A continuación, en la línea 5 se verifica que el valor del argumento

de la raíz sea positivo o cero, en cuyo caso, el proceso sigue en la línea 6 con la determinación

de las dos soluciones 𝑥1, 𝑥2 (líneas 6 y 7) para luego escribir los valores de las soluciones

(línea 8) y finalizar el proceso en la línea 18.

Si se verifica que el valor del argumento de la raíz no es positivo, el proceso continúa,

convirtiendo 𝑟 a su valor absoluto en la línea 10, determinado las soluciones y escribiéndolas

junto al mensaje correspondiente para este caso.

Por último, si la condición de la línea 3 es falsa, el proceso continuará en la línea 16 escribiendo

el mensaje y finalizando.

43

5.3.- Estructuras Repetitivas

Las estructuras repetitivas son aquellas que permiten la ejecución de un conjunto de acciones o instrucciones varias veces dentro de un algoritmo. El número de veces que dichas acciones o instrucciones se llevan a cabo, se pueden especificar a través de una condición lógica que, al ser evaluada, establece si se continúa con la repetición o la misma finaliza.

Las estructuras repetitivas están compuestas por tres partes:

• La condición lógica,

• Las acciones o instrucciones que se repiten, y

• La salida de la repetición

Existen tres tipos de estructuras repetitivas:

• Mientras

• Repetir hasta

• Para

5.3.1.- Mientras.

Permite ejecutar, repetidamente, (cero o más veces) un bloque de acciones o instrucciones,

mientras que, una determinada condición sea verdadera.

El caso más simple de este tipo de repeticiones es cuando la propia repetición está controlada

por un contador, como es el caso del siguiente ejemplo:

Ejemplo 8:

Escriba un algoritmo en DF y Pseudocódigo que muestre las raíces cuadradas de todos los números entre 11 y 30.

Análisis problema

- Datos de entrada: No se requieren datos de entrada ya que se sabe que los números corresponden a los que están entre 11 y 30

Datos de salida: Las raíces cuadradas de todos los números entre 11 y 30.

- Proceso: Inicializar un contador en 11 el cual debe llegar hasta 30, con incrementos de 1, y para cada número mostrar la raíz cuadrada.

- Restricción: No existen restricciones.


- Inicializar un contador en 11 el cual debe llegar hasta 30, con incrementos de 1, y para cada número mostrar la raíz cuadrada. Luego de mostrar todas las raíces, finalizar.

44


Figura 55: DF; Raíces cuadradas entre 11 y 30

Comentario: Como se observa en la figura anterior (figura 55), después de iniciado el

proceso, se asigna a 𝑐 el valor 11. Esta acción se denomina inicializador del contador. Esta

acción es necesaria para asegurar que el contador 𝑐 parte en el valor que el problema requiere.

𝑐 es el contador ya que mediante él se controla el número de repeticiones que se necesitan

realizar.

Después de escribir el valor de la raíz cuadrada de 𝑐 es necesario asignar 1 más al valor de 𝑐,

ya que con ello se asegura que en algún momento el valor de 𝑐 pasará de 30, con lo cual las

repeticiones terminaran.

45


Figura 56: Pseudocódigo; Raíces cuadradas entre 11 y 30

Comentario: En la línea 2 se inicializa el contador. En la línea 3 se maneja la condición lógica

para controlar la repetición, la cual terminará cuando el contador 𝑐 deje de ser menor o igual

que 30.

En la línea 5 se incrementa en 1 el contador 𝑐 para asegurar que la repetición termine, luego

de lo cual terminará el proceso en la línea 7.

Ejemplo 9:

Diseñe un algoritmo representándolo en DF y Pseudocódigo que muestre todos los divisores de un número entero positivo cualquiera.

Análisis problema

- Datos de entrada: Un número entero positivo

Datos de salida: Todos los divisores del número.

- Proceso: Leer un número, verificar si es entero y positivo y, determinar y mostrar todos sus divisores.

- Restricción: El algoritmo sólo debe tratar con números enteros y positivos


- Leer un número, verificar que sea entero y positivo, de ser así, determinar y mostrar todos sus divisores.

46


Figura 57: DF; Divisores de un entero

Comentario: Como se observa en la figura anterior (figura 57), el proceso comienza con el

ingreso de un número, luego de lo cual se verifica que sea positivo (𝑛 > 0) y además que sea

entero, para lo cual se utiliza el operador MOD que lo que hace, es devolver el resto de la

división entre dos números. Así si 𝑛 es entero, al dividirlo por 1, deberá tener resto 0.

Si las dos condiciones lógicas anteriores son verdaderas, el proceso continuará por la rama de

la derecha (V), con lo cual se asigna a 𝑐 (contador) el valor 1 y se entra a la condición de la

repetición mientras.

Como se observa en la condición lógica del mientras, la repetición continuará mientras 𝑐 sea

menor o igual que 𝑛.

En la repetición se usa también el operador MOD pero ahora con el propósito de verificar si

el resto de la división entre 𝑛 y 𝑐 es cero, ya que de ser así podemos asegurar que 𝑐 es divisor

de 𝑛. Dentro de la repetición se debe considerar el incremento del valor del contador 𝑐 para

que la repetición trabaje adecuadamente. Cuando la repetición mientras finalice, se finalizará

también el proceso.

Si la verificación para determinar si el número es estero y positivo falla (F), se escribirá el

mensaje ‘Error’ y el proceso terminará.

47


Figura 58: Pseudocódigo; Divisores de un entero

Comentario: En la línea 4 se inicializa el contador. En la línea 5 se maneja la condición lógica

para controlar la repetición, la cual terminará cuando el contador 𝑐 deje de ser menor o igual

que 𝑛.

En la línea 6 se tiene la condición lógica para determinar si 𝑐 es divisor de 𝑛, lo cual se verifica

si el resto de la división entre 𝑛 y 𝑐 es cero. Si la condición es verdadera se escribe el valor de

𝑐 en la línea 7.

El incremento del contador 𝑐 se ha puesto fuera de la condición lógica, ya que esta acción

debe realizarse independientemente de si la condición es verdadera o falsa.

En la línea 12 está el escribir que deberá ejecutarse si la condición lógica que verifica si 𝑛 es

positivo y entero, es falsa.

Ejemplo 10:

Diseñe un algoritmo representándolo en DF y Pseudocódigo que determine y muestre suma de todos los divisores de un número entero positivo cualquiera.

Análisis problema

- Datos de entrada: Un número entero positivo

Datos de salida: La suma de todos los divisores del número.

- Proceso: Leer un número, verificar si es entero y positivo y, determinar sus divisores y sumarlos, y mostrar la suma de todos sus divisores.

- Restricción: El algoritmo sólo debe tratar con números enteros y positivos


- Leer un número, verificar que sea entero y positivo, de ser así, determinar sus divisores y sumarlos, luego de ello mostrar la suma de todos sus divisores.

48


Figura 59: DF Suma de los divisores de un entero

Comentario: En esencia este problema es muy similar al anterior. La diferencia está que en

lugar se mostrar los divisores del número, estos deben ir sumándose para mostrar la suma una

vez finalizada la repetición.

Para sumar cada uno de los divisores del número, se ha usado un acumulador de suma que en

este caso es 𝑠. Se denomina acumulador de suma ya que, como se observa en el DF, en esta

variable se va sumando cada 𝑐 que se verifica que es divisor de 𝑛.

Cuando se usan acumuladores estos deben inicializarse para asegurar que acumulan sólo los

valores que interesan, y esta inicialización debe estar fuera de la repetición, lo que en este caso

que se trata de un acumulador de suma, la variable debe inicializarse a cero.

49


Figura 60: Pseudocódigo; Suma de los divisores de un entero

50

5.3.2.- Repetir.

Este tipo de estructura algorítmica es muy similar a la estructura repetitiva Mientras, siendo su principal diferencia (como se mostrará en los siguientes ejemplos), el hecho de que la condición lógica que determina si se continúa con la repetición, se encuentra al final de la propia estructura repetitiva.

Utilizando los fragmentos de DF que se muestran en la siguiente figura explicamos esta diferencia.

Figura 61: DF (1); Diferencia Mientras (A), Repetir (B)

Antes que nada, partamos por reconocer que tanto el fragmento A como el B, al ser

ejecutados, escribirán el mismo valor de 𝒄 una vez que terminen sus repeticiones, y el cual corresponde a 5

Como se observa en el fragmento B la condición lógica para continuar o terminar las

repeticiones se ubica al final de la propia repetición, con lo cual se requiere escribirla de manera

diferente que para el caso A.

Figura 62: Pseudocódigo (1); Diferencia Mientras (A), Repetir (B)

En la Figura 62 se presentan las equivalencias en Pseudocódigo de los fragmentos A y B mostrados en la Figura 53

A B

A B

51

Como se observa, para el caso de la estructura Repetir se utilizan la secuencia de palabras

claves Repetir y Hasta Que y en esta última se incorpora la condición lógica

Si bien en muchos algoritmos se pueden usar indistintamente las estructuras repetitivas

Mientras o Repetir, es importante tener en claro que el hecho de que la condición lógica

para controlar la repetición se encuentra al final de una estructura Repetir, esto puede

ocasionar repeticiones no deseadas para algunos casos.

Vemos el siguiente ejemplo para ilustrar lo que estamos señalando.

Figura 63: DF; Repeticiones Mientras (A) y Repetir (B) no equivalentes

Teniendo en cuenta los DF de la Figura anterior (Figura 63) y suponiendo que 𝒄 antes de la repetición Mientras en (A) tienen cualquier valor superior a 4 dicha repetición nunca se ejecutará, sin embargo, si es el mismo caso para el Repetir en (B), ésta se ejecutará una vez.

En la siguiente figura se muestran los Pseudocódigos correspondientes a los DF anteriores.

Figura 64: Pseudocódigo; Repeticiones Mientras (A) y Repetir (B) no equivalentes

Para ejemplificar la estructura repetitiva Repetir usaremos los mismos ejemplos que mostrados para la estructura Mientras.

Ejemplo 11:

Diseñe un algoritmo representándolo en DF y Pseudocódigo que muestre las raíces cuadradas de todos los números entre 11 y 30.

A B

A B

52

Representación Algorítmica

Figura 65: DF y Pseudocódigo; Raíces cuadradas entre 11 y 30 usando Repetir

53

Ejemplo 12:



Figura 66: DF y Pseudocódigo; Divisores de un entero usando Repetir

54

Ejemplo 13:



Figura 67: DF y Pseudocódigo; Suma de los divisores de un entero usando Repetir

55

5.3.3.- Para.

Este tipo de estructura algorítmica es la tercera forma de estructura repetitiva, siendo su

principal característica, ser una estructura más compacta en lo referido al control de las

repeticiones, respecto de las otras dos.

Para explicar esto partiremos mostrado primero su Pseudocódigo:

Figura 68: Pseudocódigo; Elementos de la estructura de repetición Para De donde:

En DF esta estructura tiene la siguiente forma y elementos.

Figura 69: DF; Forma y elementos de la Repetición Para

El siguiente es un ejemplo sencillo donde se ilustra el funcionamiento de la estructura Para y

la relación entre los elementos del DF y el Pseudocódigo.

Nombre de una variable numérica que se utilizará para controlar

el número de repeticiones.

Valor inicial que tomará la variable numérica al comenzar las repeticiones.

Valor final que tendrá la variable numérica para finalizar las repeticiones.

Valor del incremento o decremento que tendrá la variable numérica en cada repetición.

56

Figura 70: Funcionamiento y Elementos de la estructura repetitiva Para

Para ejemplificar la estructura repetitiva Para al igual que en los casos anteriores, usaremos

los mismos ejemplos que se han mostrado hasta ahora.

Ejemplo 14:

Diseñe un algoritmo representándolo en DF y Pseudocódigo que muestre las raíces cuadradas de todos los números entre 11 y 30.


Figura 71: DF y Pseudocódigo; Raíces cuadradas entre 11 y 30 usando Para

57

Comentario: Como se observa en la figura anterior (Figura 71), la repetición Para posee una estructura más compacta que Mientras y Repetir, ya que por una parte no requiere de la inicialización de la variable que controla el número de repeticiones antes de la propia estructura repetitiva, y además no necesita una condición lógica para establecer en cuando se terminan las repeticiones. Sin embargo, es importante aclarar que, aunque la condición lógica no está de manera explícita, si lo está de forma implícita en la palabra clave Hasta contenida en la cabecera de la estructura.

Ejemplo 15:



Figura 72: DF y Pseudocódigo; Divisores de un entero usando Para

58

Ejemplo 16:



Figura 73: DF y Pseudocódigo; Suma de los divisores de un entero usando Para

59

6. PROBLEMAS PROPUESTOS DE DISEÑO DE ALGORITMOS

6.1.- Problemas propuestos cuyas soluciones usan estructuras Selectivas

1. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre la longitud de una circunferencia. El algoritmo debe considerar las validaciones de datos que sean necesarias. Realice una implementación que use el radio y otra que use el diámetro.

2. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre el área basal y el volumen de un cilindro El algoritmo debe considerar las validaciones de datos que sean necesarias. Realice una implementación que use el radio y otra que use el diámetro.

3. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre la longitud de la hipotenusa de un triángulo rectángulo. El algoritmo debe considerar las validaciones de datos que sean necesarias.

4. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre para un cierto tiempo en segundos, los segundos restantes que le correspondan para convertirse exactamente en minutos. El algoritmo debe considerar las validaciones de datos que sean necesarias.

5. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre el área de un triángulo cualquiera. El algoritmo debe considerar las validaciones de datos que sean necesarias.

6. Diseñe un algoritmo representándolo en DF y Pseudocódigo que determine si un número es par o impar.

7. Diseñe un algoritmo representándolo en DF y Pseudocódigo que reciba dos números enteros y escriba el mensaje "signos opuestos" solo si uno es positivo y el otro es negativo.

8. Diseñe un algoritmo representándolo en DF y Pseudocódigo que reciba dos enteros positivos y distintos. A partir de ellos escriba la diferencia entre el número mayor y el número menor. Asegúrese que su algoritmo escriba 6 tanto cuando los números ingresados sean 9 y 15 como cuando la entrada sea 15 y 9.

9. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita ingresar dos números y muestre si estos fueron ingresados en orden ascendente o en orden descendente.

10. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita ingresar dos números y muestre el mayor de ellos.

11. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita ingresar tres números y muestre cual es el mayor y cuál es el menor. El algoritmo debe considerar la posibilidad de que dos o tres de los números puedan ser iguales.

12. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita ingresar tres números y los muestre en orden ascendente. El algoritmo debe considerar la posibilidad de que dos o tres de los números puedan ser iguales.

13. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita ingresar la edad de una cierta persona, y muestre el mensaje NIÑO si la edad es hasta 10; el mensaje “PUBER” si la edad es mayor que 10 y menor o igual 14; el mensaje “ADOLESCENTE” si la edad es mayor que 15 y menor o igual 18; el mensaje “JOVEN” si la edad es mayor que 19 y menor o igual 25; el mensaje “ADULTO” si la edad es mayor que 26 y menor o igual 65; y el mensaje “ANCIANO” si la edad es mayor que 65. El algoritmo debe considerar las validaciones de datos que sean necesarias.

60

14. Unas camisas se venden a $4.000 cada una si se compran más de tres y a $4.800 en los demás casos. Diseñe un algoritmo representándolo en DF y Pseudocódigo que lea el número de camisas compradas y muestre el costo total de la compra. El algoritmo debe considerar las validaciones de datos que sean necesarias.

15. Considere un caso similar al anterior, pero donde el valor de las camisas no es constante y se aplican porcentajes de descuento dependiendo de la cantidad de camisas compradas. El algoritmo debe considerar las validaciones de datos que sean necesarias.

16. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita calcular y mostrar las raíces que son solución de una ecuación de segundo grado. El algoritmo debe recibir como entrada los coeficientes A, B y C. Si el coeficiente A es cero, el algoritmo deberá entregar un mensaje que indique que el coeficiente no corresponde a una ecuación de 2° grado. Además, se deberá entregar un mensaje cuando la solución sea imaginaria (se cumple que el valor del argumento B2-4*A*C < 0).

17. Diseñe un algoritmo representándolo en DF y Pseudocódigo para determinar si tres enteros a, b y c son o no una terna pitagórica, es decir, si es posible que a2 + b2 = c2 ó a2 + c2 = b2 ó b2 + c2 = a2

18. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita determinar si un conjunto de tres magnitudes de lados ingresados, pueden forman un triángulo. En el caso de que así sea, el algoritmo debe determinar si el triángulo que forman es equilátero, isósceles o escaleno. El algoritmo debe considerar las validaciones de datos que sean necesarias.

19. Una cierta empresa de distribución de electricidad ha fijado las siguientes tarifas para aplicar los cobros a sus clientes:

• Hasta de 50 KWH, $30 por cada KWH

• Más 50 KWH y hasta 100 KWH, $35 por cada KWH de exceso, y

• Más de 100 KWH $42 por cada KWH de exceso.

Diseñe un algoritmo representándolo en DF y Pseudocódigo tal que, al ingresar el consumo de

un cliente, calcule el valor que deberá pagar. Este valor debe incluir el impuesto IVA. El algoritmo

debe considerar las validaciones de datos que sean necesarias.

20. En una cierta empresa de ha decidido aplicar un reajuste de sueldos a sus empleados, para lo cual se tomarán en consideración la antigüedad y el sueldo actual según la siguiente tabla:

Hasta 10 años de

antigüedad y:

Sueldo actual hasta $300.000; 12% de reajuste

Sueldo actual más de $300.000 y hasta $500.000 10% de

reajuste

Sueldo actual superior a $500.000; 8% de reajuste

Más de 10 años de

antigüedad y hasta 20 y:

Sueldo actual hasta que $300.000; 14% de reajuste

Sueldo actual más de $300.000 y hasta $500.000 12% de

reajuste

Sueldo actual más de $500.000; 10% de reajuste

Para todas las antigüedades iguales o superiores a 20 años se aplicará un reajuste de 15% sin

importar el sueldo actual.

61

Diseñe un algoritmo representándolo en DF y Pseudocódigo tal que ingresada la antigüedad y

el sueldo actual determine el nuevo sueldo del empleado. El algoritmo debe considerar las

validaciones de datos que sean necesarias.

21. En una cierta empresa comercial, el sueldo mensual de los vendedores corresponde a la suma de un sueldo base, más una comisión que corresponde a un porcentaje de las ventas que el vendedor haya efectuado en el mes.

Para cálculo de la comisión que le corresponde a cada vendedor por las ventas que realizó

durante el mes, se usa la siguiente tabla:

• Si las ventas fueron inferiores a $4.000.000 el vendedor no recibe comisión,

• Si las ventas fueron iguales a $4.000.000 y menos de $10.000.000 la comisión es de un 3% de las ventas, y

• Si las ventas fueron iguales o superiores a $10.000.000 la comisión es de un 7% de las ventas

Diseñe un algoritmo representándolo en DF y Pseudocódigo tal que ingresado el sueldo base

del vendedor y el monto de las ventas que efectuó en el mes, calcule y muestre el sueldo mensual

que le corresponde. El algoritmo debe considerar las validaciones de datos que sean necesarias.

22. El sueldo semanal de los trabajadores de una cierta fábrica está compuesto por un sueldo base, más la valorización de las horas extraordinarias que acumulen dentro de la semana de trabajo. Para calcular la valorización de las horas extraordinarias se utiliza la siguiente tabla:

• Cada hora extraordinaria en horario normal (entre las 7 A.M. y las 12 P.M.) tienen un valor de $2.000

• Cada hora extraordinaria en horario nocturno (entre las 12 P.M. y las 7 A.M.) tienen un valor de 1,3 veces la del horario normal.

Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule el sueldo semanal de un trabajador cualquiera de esta fábrica.

23. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita calcular y mostrar el valor de la función y sabiendo que:

• Para los x < 0; y = 3x2 + 5x-10.21

• Para los 10 <= x <30; y = 3.2x+2.8

• Para los x >=30; y = 1.2 – 5.5x6

24. Un trabajador de una cierta empresa recibe un sueldo mensual que está determinado por el producto entre el número de horas que trabajó durante el mes y el valor de cada hora, pero si el trabajador labora más de 40 horas, su valor hora para las horas sobre 40, se incrementa en el 60% de su valor. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre el sueldo que le corresponde a un trabajador cualquiera de esta empresa. Considere las validaciones de datos que sean necesarias.

25. En una biblioteca se ha implementado una forma un tanto especial de cobrar multas por retrasos en la entrega de préstamos de los usuarios.

62

• El primer día de retraso de un préstamo a domicilio, tiene una multa de $400 y cada día

adicional tiene una multa de $600.

• Si un usuario tiene más de tres días de retraso, además de la multa, se le aplicará una suspensión de una semana.

Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre la multa por

retraso a cobrar a un usuario cualquiera, y la suspensión cuando corresponda. El algoritmo debe

hacer las validaciones que sean necesarias.

26. Un cierto criadero de árboles que comercializa paltos, limones y chirimoyos, ha establecido la siguiente tabla de precios unitarios sin IVA y los porcentajes de rebajas que se aplican según la cantidad de árboles que se compran:

Tipo de

árbol

Precio

unitario

Rebaja por compras mayores

que 100 y hasta 300 árboles

Rebaja por compras

mayores que 300 árboles

Paltos $1.200 10% 18%

Limones $1.000 12,5% 20%

Chirimoyos $980 14,5% 19%

Además, se ha considerado que si un cliente compra una cantidad superior a 1.000 árboles sean

estos de un solo tipo o de una combinación de ellos, tendrá una rebaja adicional de un 15%

Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre el valor a

pagar por una compra cualquiera de árboles, teniendo en cuenta que este valor a pagar debe

considerar el impuesto IVA. El algoritmo debe realizar las validaciones que sean necesarias.

27. Una cierta compañía telefónica que ofrece servicio internacional ha establecido las siguientes tarifas con IVA incluido para sus clientes.

• USA, $150 los primeros 3 minutos, $60 cada minuto adicional

• ESPAÑA, $120 los primeros 3 minutos, $50 cada minuto adicional

• BRASIL, $180 los primeros 3 minutos, $70 cada minuto adicional

• MEXICO, $160 los primeros 3 minutos, $65 cada minuto adicional

Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita calcular y mostrar el

valor de una llamada cualquiera. El algoritmo debe realizar las validaciones que sean necesarias.

Se sugiere que identifique cada tipo de llamada mediante un número entero, como por ejemplo:

1 para USA, 2 para ESPAÑA, 3 para BRASIL, y 4 para MEXICO.

28. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre los valores que son propios de una factura, esto es el VALOR NETO, el VALOR DEL IMPUESTO IVA, y el VALOR A PAGAR. Debe considerar que la venta es de un solo tipo de artículo, pero puede hacerse por varias unidades del mismo artículo.

Considere además que si el valor a pagar es mayor que $100.000 se debe aplicar un descuento

del 5% al VALOR A PAGAR. El algoritmo debe realizar las validaciones que sean necesarias.

63

6.2.- Problemas propuestos cuyas soluciones usan estructuras Repetitivas

1. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita determinar y mostrar la suma de los números enteros del 1 al 1000

2. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita ingresar un número entero positivo y muestre la suma de todos los números comprendidos entre 0 y el número ingresado. El algoritmo debe considerar las validaciones de datos que sean necesarias.

3. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita calcular y mostrar la suma y el producto de los números pares comprendidos entre 20 y 400 ambos inclusive.

4. Diseñe un algoritmo representándolo en DF y Pseudocódigo tal que ingresados 10 números enteros, muestre la suma de los números pares, la cantidad de números pares y el promedio de los mismos. El algoritmo debe considerar las validaciones de datos que sean necesarias.

5. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita determinar si un número entero cualquiera es par o impar. El algoritmo debe considerar las validaciones de datos que sean necesarias.

6. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita determinar si un cierto número es entero o no.

7. Diseñe un algoritmo representándolo en DF y Pseudocódigo tal que ingresados 20 números, muestre la suma de los números positivos.

8. Diseñe un algoritmo representándolo en DF y Pseudocódigo que lea dos números enteros positivos y los multiplique por sumas sucesivas. El algoritmo debe mostrar el resultado y debe considerar las validaciones de datos que sean necesarias.

9. Diseñe un algoritmo representándolo en DF y Pseudocódigo que divida números enteros positivos por medio de restas sucesivas y que muestre el resultado de la división. El algoritmo debe considerar las validaciones de datos que sean necesarias.

10. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita muestre todos los divisores de un cierto número entero. El algoritmo debe considerar las validaciones de datos que sean necesarias.

11. Escriba un algoritmo que permita determinar si un cierto número entero es primo.

12. Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita determinar y mostrar el factorial de un número entero positivo. El algoritmo debe considerar las validaciones de datos que sean necesarias.

13. Diseñe un algoritmo representándolo en DF y Pseudocódigo para determinar y mostrar la potencia de un número real elevado a un cierto exponente entero positivo. El algoritmo debe considerar las validaciones de datos que sean necesarias.

14. Diseñe un algoritmo representándolo en DF y Pseudocódigo para determina y mostrar la potencia de un número real elevado a un cierto exponente entero. El algoritmo debe funcionar correctamente tanto para exponentes positivos como negativos y debe considerar las validaciones de datos que sean necesarias.

15. Diseñe un algoritmo representándolo en DF y Pseudocódigo al cual se le ingresen 10 valores y al final muestre por pantalla la suma de los valores, la suma de los cuadrados de ellos, el promedio, el máximo y el mínimo de los mismos.

64

16. La compañía XYZ tiene una fórmula poco común para calcular los sueldos de sus empleados. El sueldo semanal para un empleado es: $35.000+$(edad del empleado)+$100*(1+2+3+...+ años en XYZ). Así entonces un empleado de 37 años de edad que tiene una antigüedad de 6 años en XYX ganaría un sueldo de: $35.000+$37+$2100 lo que da un total de $37.137.

Diseñe un algoritmo representándolo en DF y Pseudocódigo que reciba para un empleado la

edad y antigüedad en XYZ y muestre el sueldo que le corresponde semanalmente. El algoritmo

debe considerar las validaciones de datos que sean necesarias.

17. Diseñe un algoritmo representándolo en DF y Pseudocódigo tal que ingresados 100 números naturales, permita determinar y mostrar:

a. ¿Cuántos son menores que 15?

b. ¿Cuántos son mayores que 50?

c. ¿Cuántos están comprendidos entre 25 y 45?

d. ¿Cuál es el promedio de los 100 números?

El algoritmo debe considerar las validaciones de datos que sean necesarias.

18. Dos números enteros positivos a y b son amigos, si la suma de los divisores propios de uno es igual al otro número y viceversa (la unidad es divisor propio de cualquier número, sin embargo, el propio número no se considera divisor propio Un ejemplo es el par de naturales (220, 284), ya que: los divisores propios de 220 son 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 y 110, que suman 284; y los divisores propios de 284 son 1, 2, 4, 71 y 142, que suman 220.

Diseñe un algoritmo representándolo en DF y Pseudocódigo que permita verificar si dos

números enteros positivos cualesquiera son o no amigos. El algoritmo debe considerar las

validaciones de datos que sean necesarias.

19. Diseñe un algoritmo representándolo en DF y Pseudocódigo que reciba dos enteros positivos y devuelva uno, si los números recibidos son primos relativos y devuelva cero en caso contrario. Dos números son primos relativos si no tienen divisores comunes excepto la unidad. El algoritmo debe considerar las validaciones de datos que sean necesarias.

20. Un número abundante es todo número entero positivo que cumple que la suma de sus divisores propios es mayor que el propio número. Por ejemplo, 12 es abundante ya que sus divisores propios son 1, 2, 3, 4 y 6 y se cumple que 1+2+3+4+6=16, que es mayor que 12.

Diseñe un algoritmo representándolo en DF y Pseudocódigo que verifique si un cierto número

entero positivo es abundante. El algoritmo debe considerar las validaciones de datos que sean

necesarias.

21. Diseñe un algoritmo representándolo en DF y Pseudocódigo que determine y muestre la suma de n elementos de la serie numérica 1, 5, 3, 7, 5, 9, 7, …. . El algoritmo debe considerar las validaciones de datos que sean necesarias.

22. Diseñe un algoritmo representándolo en DF y Pseudocódigo que determine y muestre el valor de la serie

s = 1 + x + (x2/2!) + (x3/3!) + ….(xn/n!) para un cierto x y n dados


http://es.wikipedia.org/wiki/Divisibilidad#Factor_propio

65

23. Diseñe un algoritmo representándolo en DF y Pseudocódigo que determine y muestre el valor de

la serie

s = 1 +(1 + x) + (2 + x)2/2! + (3 + x)3/3! + ….(n + x)n/n! para un cierto x y n dados


24. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre el valor de la función seno de un ángulo cualquiera usando serie de Taylor. El algoritmo debe considerar las validaciones de datos que sean necesarias.

25. Diseñe un algoritmo representándolo en DF y Pseudocódigo que calcule y muestre el valor de la función coseno de un ángulo cualquiera usando serie de Taylor. El algoritmo debe considerar las validaciones de datos que sean necesarias.

66

Referencias

Características y Funcionalidades de PSeInt, disponible en, http://pseint.sourceforge.net/features.php, visitado el 5 de abril de 2018

Descubra PSeInt, disponible en; http://pseint.sourceforge.net/slide/pseint.html, visitado el 5 de abril de 2018

Sitio de descarga de la Aplicación PSeInt, disponible en: http://pseint.sourceforge.net, visitado el 20 de abril de 2018

http://pseint.sourceforge.net/slide/pseint.html


cuaderno docente manual para la asignatura … · externas que configuran la organización de un...

Documents