herramientas de diseÑo de algoritmos introducción
TRANSCRIPT
i
UNIVERSIDAD NACIONAL DE EDUCACIÓN
Enrique Guzmán y Valle
Alma Máter del Magisterio Nacional
FACULTAD DE CIENCIAS
Escuela Profesional de Matemática e Informática
MONOGRAFÍA
HERRAMIENTAS DE DISEÑO DE ALGORITMOS
Introducción. Estructura del algoritmo en el programa. Comandos e
instrucciones con ejemplos. Pseint. DFD. Herramientas principales,
aplicaciones.
Examen de Suficiencia Profesional Res. N°0503-2019-D-FAC
Presentada por:
Pezo Zuta, Jaime
Para optar al Título de Segunda Especialidad Profesional
Especialidad: Informática Educativa
Lima, Perú
ii
2
iii
Dedicatoria:
Para mi amada esposa Hilda, mis tres
amados hijos y padres que son mi
inspiración de superación personal y
profesional.
iv
Índice de contenidos
Carátula ................................................................................................................................... i
Hoja de firmas del jurado…………………………………………………………………...ii
Dedicatoria........................................................................................................................... iii
Índice de contenidos………………………………………………………………....…….iv
Lista de tablas……………………………………………………………………………....vi
Lista de figuras .................................................................................................................... vii
Introducción .......................................................................................................................... ix
Capítulo I. Algoritmos ......................................................................................................... 10
1.1 Algoritmos ..................................................................................................................... 10
1.2 Características ................................................................................................................ 11
1.3 Partes de un algoritmo ................................................................................................... 11
1.4 Estructuras y componentes ............................................................................................ 13
1.4.1 Estructuras. ........................................................................................................... 13
1.4.2 Orígenes de las estructuras. .................................................................................. 13
1.5 Representación de algoritmos ........................................................................................ 16
1.5.1 Flujogramas .......................................................................................................... 16
1.5.2 Reglas de diagramas de flujo. ............................................................................... 17
1.6 Herramientas principales ............................................................................................... 22
Capítulo II. Conversión de algoritmos ................................................................................ 24
2.1 Concepto ........................................................................................................................ 24
2.1.1 Solución de problemas por medio de computadoras. ........................................... 25
2.1.2 Metodología para la solución de problemas por medio de computadora. ............ 26
2.2 Lenguajes de programación ........................................................................................... 26
2.2.1 Instrucciones de la computadora. ......................................................................... 27
v
2.2.2 Lenguaje máquina................................................................................................ 27
2.2.3 Lenguajes de bajo nivel. ...................................................................................... 27
2.2.4 Lenguajes de alto nivel. ....................................................................................... 28
2.2.5 Traductores de lenguaje. ...................................................................................... 28
2.2.6 La compilación y sus fases. ................................................................................. 29
Capítulo III. Aplicaciones principales ................................................................................. 30
3.1 PSeInt............................................................................................................................. 30
3.1.1 Características del Pseint. ...................................................................................... 30
3.2 DFD ............................................................................................................................... 35
3.3 Java Netbeans ................................................................................................................ 40
Aplicación didáctica ............................................................................................................ 46
Síntesis ................................................................................................................................. 52
Apreciación crítica y sugerencias ........................................................................................ 53
Referencias .......................................................................................................................... 54
vi
Lista de tablas
Tabla 1. Uniformalización del pseudocódigo……………………………………………21
vii
Lista de figuras
Figura 1. Resolución de problemas con algoritmos………………………….……………10
Figura 2. Simbología………………………………………………………………………17
Figura 3. Ejemplo de construcción de un diagrama de flujo………………………………18
Figura 4. Diagrama de flujo para mostrar en pantalla……………………………………..19
Figura 5. Representación de un algoritmo…………………………………………….…..20
Figura 6. Estructura condicional en N-S……………………………………………….….20
Figura 7. Representación del cálculo del salario neto de un trabajador……………….…..21
Figura 8. Estructura secuencial……………………………………………………………22
Figura 9. Diagrama N-S de una estructura secuencial…………………………………….22
Figura 10. Sistemas de proceso de datos…………………………………………………..24
Figura 11. Programa ensamblador………………………………………………………...27
Figura 12. Intérprete……………………………………………………………………….28
Figura 13. La compilación de programa…………………………………………………..28
Figura 14. Fases de la compilación……………………………………….……………….29
Figura 15. Instalación de Pseint…………………………………………………………...31
Figura 16. Abrir Pseint……………………………………………………………….32
Figura 17. Ventana de Pseint abierta…………………………………………………32
Figura 18. Ingreso de sintaxis…………………………………………………………….33
Figura 19. Guardar archivo………………………………………………………………..33
Figura 20. Ventana para guardar…………………………………………………………..34
Figura 21. Ícono de ejecutar……………………………………………………………….34
Figura 22. Ventana de ejecución finalizada……………………………………………….35
viii
Figura 23. Ventana de edición…………………………………………………………….35
Figura 24. Barra de herramientas………………………………………………………….36
Figura 25. Abriendo programa DFD………………………………………………………36
Figura 26. Ingreso de edad en números…………………………………………………...37
Figura 27. Agregamos una lectura………………………………………………………...37
Figura 28. Ingreso de edad………………………………………………………………...38
Figura 29. Agregamos nueva salida……………………………………………………….38
Figura 30. Ingreso de edad en años………………………………………………………..39
Figura 31. Pantalla final de un algoritmo………………………………………………….39
Figura 32. Ejecución de algoritmo finalizada……………………………………………..40
Figura 33. Edición de código en java con Netbeans………………………………………40
Figura 34. Definición de proyecto…………………………………………………………41
Figura 35. Visualización de New Proyect………………………………………………....41
Figura 36. Ventana Java Application……………………………………………………...42
Figura 37. Selección de proyecto………………………………………………………….42
Figura 38. Carpeta nueva………………………………………………………………….43
Figura 39. New Java Application………………………………………………………….43
Figura 40. Nombre del proyecto…………………………………………………………..44
Figura 41. Desarrollo de NetBeans………………………………………………………..44
Figura 42. Inicio para la construcción en Netbeans……………………………………….45
ix
Introducción
La presente monografía titulada: Herramientas de diseño de algoritmos, explica las
características principales de las herramientas que utiliza el desarrollo de algoritmos, los
cuales son fundamentales en el diseño de soluciones. Por lo cual, el alumno debe tener
buenas bases que le permitan crear de manera fácil y rápida sus algoritmos. Los algoritmos
son un conjunto de pasos que permiten resolver un problema en nuestro caso relacionado
con el procesamiento de datos.
La importancia del estudio del tema se centra en que el conocimiento sobre
algoritmos permite orientar a los estudiantes sobre la solución de situaciones
problemáticas, de esta manera se desarrolla el pensamiento crítico.
La investigación está estructurada en 3 capítulos: Capítulo I, trata sobre las
características, estructura, representación y herramientas principales de los Algoritmos; el
capítulo II, desarrolla aspectos relacionados a la conversión de algoritmos; el capítulo III,
presenta las aplicaciones principales de Pseint, DFD y Java Netbeans. Finalmente, la
aplicación didáctica, síntesis, apreciación crítica y sugerencias, y referencias utilizadas.
10
Capítulo I
Algoritmos
1.1 Algoritmos
Algoritmo deriva de la alkhowarizmi, siendo este el nombre de un matemático árabe y
astrónomo del sigo IX cuya obra trata sobre la manipulación de números y ecuaciones
mediante procesos continuos hasta resolverlos.
También podemos definir a los algoritmos es una serie de pasos los cuales dan
solución a un problema específico. Los algoritmos deben cumplir con algunas
características fundamentales como el que debe tener un valor finito de pasos, ósea tiene
un inicio y un término. De acuerdo al sistema operativo vernos que los algoritmos no
cambian sino se adaptan. La resolución de un problema exige el diseño de un algoritmo
que resuelva el problema propuesto.
Figura 1. Resolución de problemas con algoritmos. Fuente: Autoría propia.
11
Según Galve (1993) “de acuerdo a las etapas, en el análisis se concluyen los
objetivos que realizara cada programa, en el diseño la forma de realizarlo” (p.48).
Las etapas de la resolución de problemas son:
❖ Diseño del algoritmo como la consecución de pasos para lograr los objetivos deseados.
(análisis y desarrollo del algoritmo).
❖ El algoritmo puede ser trasladado a cualquier lenguaje de programación establecido.
(codificación).
❖ Ejecución del programa.
(en el diseño se debe tener el raciocinio y creación de procesos sobre la programación).
1.2 Características
A continuación, veremos las características propuestas por Joyanes (2008):
❖ Precisión: Nunca deben ser ambiguos la lógica y las instrucciones deben
comprenderse fácilmente.
❖ Definición: Puede probarse varias veces y el resultado debe ser el mismo, siendo de
esta manera fiable.
❖ Finitud: Debe tener un inicio y un fin.
❖ Legibilidad: Debe ser fácil.
❖
1.3 Partes de un algoritmo
“Los algoritmos tienen tres componentes principales: entrada, proceso y salida” (Joyanes,
2008, p. 65).
Entrada: Es el punto de inicio de un algoritmo, donde se específica el nombre.
Proceso: Es el espacio del cuerpo del algoritmo, donde se desarrolla todo el proceso paso a
paso.
12
Salida: Es el término del algoritmo.
Ejemplos: Un cliente realiza un pedido a una botica. La botica revisa la identidad
de la ficha del cliente, si el cliente es reconocido como cliente acepto el pedido: en caso
contrario, se ingresa el cliente y se realiza el pedido. Redactar el algoritmo
correspondiente.
Los pasos son:
Inicio
Leer la identidad del cliente
Examinar la base de datos del cliente
Si el cliente existe, se acepta el pedido; de lo contrario, se ingresa como nuevo cliente y se
realiza el pedido.
Fin.
Sumar los primos entre 1 y 1000.
Tiene como objetivo acumular los números primos entre 1 a 1000.
Utilizamos las palabras Suma y Acumulador para representar las sumas sucesivas
(1+2+3+5+…), etc.
Escribir el siguiente algoritmo:
Inicio
Declara las variables número, suma, acumulador
Repetir secuencia hasta que numero sea = 1000
Determinar si es número primo.
Sí es primo y = <1000 acumula el número en Acumulador y retornar al paso 6
en caso contrario, retornar al paso 6.
Leer numero adicionando la unidad
13
Retorna al paso 3
Fin
1.4 Estructuras y componentes
Para poder resolver un problema se realiza una secuencia de pasos el cual pude utilizar
estructuras y componentes que faciliten el procedimiento. Tienen como características:
-Tienen secuencia definida hasta obtener los resultados.
-Sólo puede ejecutarse una operación a la vez.
1.4.1 Estructuras.
Las estructuras están referidas a un conjunto de procedimientos. Estas técnicas
aumentan considerablemente la productividad del programa. Puede utilizar estructuras de
control que minimizan la complejidad de los problemas y, por consiguiente, reducen los
errores.
1.4.2 Orígenes de las estructuras.
Para Corona (2008) “desde 1960 surge la programación estaban escritos de manera
que facilitaba su comprensión en cualquier momento” (p. 28). Desde hace varias décadas
que se viene estudiando la programación.
Un algoritmo estructurado, según Corona (2008) “puede utilizar solo tres
instrucciones estructurados: Secuencias, Condicionales e Iteraciones” (p. 31).
a) Estructura secuencial
Es secuencial solo cuando se ejecutan los procesos una tras otra, es decir la instrucción se
ejecuta una tras una y solo avanza cuando finaliza la anterior.
b) Estructura selectiva o de selección
Ejecuta las instrucciones secuencialmente hasta encontrar una expresión lógica donde se
tendrá que decidir entre dos alternativas, verdadero o falso y continuará de acuerdo a esta.
14
Ejemplo: Si a mayor que b entonces, imprimir " a es mayor que b";
de lo contario imprimir " a no es mayor que b "
Fin de si
Pueden ser:
Simples
Dobles
Múltiples
c) Estructura simple (if – then)
Realiza la ejecución de acuerdo a la decisión lógica
Pseudocódigo
If <condición> then
<acción Si> <acción Si>
End if
d) Alternativa doble (if – then - else)
“Cuando ambas alternativas pueden ocurrir una a una pero nunca ambas a la vez, se escoge
una de ellas” (Joyanes, 2008, p.54).
Pseudocódigo
If <expression lógica > then (si es verdadera)
<acción S1>
Else (si es falsa)
<acción S2>
End if
e) Alternativa múltiple (case)
15
Cuando puede contener múltiples alternativas, por lo que se debe de elegir la alternativa
que corresponde.
Ejemplo:
Case <expresión>of
Caso1: acción S1
Caso2: acción S2
Otro Caso: acción Sn
Else
Acción Sx
End_case
f) Estructura iterativa
La estructura de iteración o bucle, Loop, etc., es cuando un grupo de instrucciones repiten
un número determinado de veces, esta determinación puede ser una condición lógica.
Ejemplo:
a= 0
b= 7
Repetir hasta que b mayor que a
imprimir a
a= a + 1
Fin de repetir
g) Anidamiento
Cuando un conjunto de instrucciones se encuentra dentro de una instrucción
condicionante.
Ejemplo:
16
Si a mayor que b entonces
Auxiliar = a
a= b
b= Auxiliar
de lo contrario
nada
Fin de si
El diseño de programación estructurada puede ser: de arriba hacia abajo (top-
Down), recursos abstractos y estructuras básicas
Recursos abstractos, cuando puede descomponer las instrucciones en acciones
mucho más sencillas.
Diseño descendente (top-down), consiste en descomponer de arriba hacia abajo la
secuencia de las instrucciones de un proceso.
1.5 Representación de algoritmos
“Los algoritmos pueden ser representados en forma gráfica como los flujogramas y en
forma literal como son los seudocódigos” (Galve, 1993, p. 96).
1.5.1 Flujogramas.
Son representaciones graficas del conjunto de instrucciones que tiene un programa
que es realizado para dar solución a un problema de procesamiento de datos.
A continuación, revisemos la siguiente figura sobre simbología:
17
Figura 2. Simbología. Fuente: Autoría propia.
1.5.2 Reglas de diagramas de flujo.
Tiene un inicio y un final.
Las conexiones son rectas, nunca se deben de cruzar.
La conexión de líneas es fundamental.
El orden es de arriba hacia abajo y de izquierda a derecha.
18
Debe ser fácil de entender.
Sin terminología.
Evitar los comentarios, salvo una situación compleja.
Si el diagrama abarca más de una hoja, debe de numerarlo y conectarlo.
Ejemplo:
Determinar el sueldo de un trabajador de acuerdo al número de horas, de la tarifa
por hora y realizar el descuento en aproximadamente el 20%.
Figura 3. Ejemplo de construcción de un diagrama de flujo. Fuente: Autoría propia.
Ejemplo: Mostar en pantalla si la edad ingresada corresponde a una persona mayor
de edad o menor de edad.
19
Figura 4. Diagrama de flujo para mostrar en pantalla. Fuente: Autoría propia.
a) Diagramas n-s o de Nassi-Schederman
Cuando los procesos se escriben en cajas contiguas y dentro de ellas cada tarea.
20
Se representa:
Figura 5. Representación de un algoritmo. Fuente: Autoría propia.
b)Una estructura condicional en N-S se representa de la siguiente manera:
Figura 6. Estructura condicional en N-S. Fuente: Autoría propia.
Determinar el sueldo semanal de un operario ingresando el número de horas y los
impuestos:
21
Figura 7. Representación del cálculo del salario neto de un trabajador. Fuente: Autoría propia.
c)Pseudocódigo
Es la representación en un lenguaje natural de las instrucciones que tienen que
seguir un programa para solucionar un problema de procesamiento de datos. Esta
representación literal tiene algunos estándares las cuales deben de ser realizadas por las
personas que se encargaran de estas tareas.
No hay reglas exactas que condición su construcción y depende del programador
utilizar generalmente los verbos en inglés para poder escribirlas.
Tabla 1
Uniformalización del pseudocódigo.
Nota: Pseudocódigo en español. Fuente: Autoría propia.
22
d)Estructura secuencial
Corona (2008) dice “Cuando las instrucciones siguen una detrás de la otra, de tal
forma que el proceso de operaciones es secuencial” (p. 82). Siempre tiene una entrada y
una salida.
Figura 8. Estructura secuencial. Fuente: Autoría propia.
e) Diagrama N-S
Figura 9. Diagrama N-S de una estructura secuencial. Fuente: Autoría propia.
1.6 Herramientas principales
El pensamiento algorítmico puede ser con:
❖ Recursividad
23
❖ Modularidad (divide y vencerás)
❖ Voracidad
❖ Algoritmos geométricos
❖ Algoritmos genéticos
24
Capítulo II
Conversión de algoritmos
2.1 Concepto
Brookshear (2006) manifiesta:
En el procesamiento los datos o la información son términos iguales, pero en esencia
los datos son aquellas representaciones de alguna característica que en forma
individual no tiene mayor trascendencia, en cambio la información si adquieren
algún valor que permite tomar decisiones (p.55).
Figura 10. Sistemas de proceso de datos. Fuente: Autoría propia.
En los sistemas de procesamiento tenemos al hardware y software.
El hardware se compone de:
Entrada=datos
Salida = información
Procesador
25
❖ El procesador. También llamada CPU, en español Unidad Central de Procesamiento,
UCP es el corazón del computador encargada de realizar todos los procesos que realiza
el computador.
❖ Las memorias. Donde se almacenan las variables que intervienen en el procesamiento
de datos, así mismo se pueden almacenar procesos íntegros.
❖ Memorias secundarias. Permiten almacenar información en dispositivos externos como
el USB, CD., etc.
❖ Dispositivos de entrada /salida (E/S). Son las representaciones de salidas de un proceso
determinado.
2.1.1 Solución de problemas por medio de computadoras.
Sistema computacional o sistema de información
❖ Programa. Son instrucciones o comandos ordenados secuencialmente que resuelven
un problema de procesamiento de datos.
❖ Lenguaje de programación. Conjunto de instrucciones con una sintaxis que permiten
la comunicación del programador con la computadora.
Pueden ser: Lenguaje de máquina (0 y 1), ensambladores, y de alto nivel (con verbos
en inglés, los cuales son generalmente los comandos).
❖ Computadora. Equipos con componentes mecánicos y electrónicos compuestos por
miles de millones de transistores que tienen como objetivo el procesamiento de datos.
❖ Programador. LA persona que tiene como objetivo resolver el problema de
procesamiento de datos utilizando un lenguaje de programación especifico.
❖ Usuario. Es la persona que interactúa con el sistema de información, o mejor dicho
con la computadora.
26
2.1.2 Metodología para la solución de problemas por medio de computadora.
Brookshear (2006) dice:
Aunque nuestro objetivo es solo conocer el fundamento teórico de los algoritmos y
no implantar sistemas computacionales, se definirán las etapas que generan los
sistemas de información, y en particular donde intervienen los algoritmos, siendo la
etapa más importante y corresponde a la construcción de los programas (p. 89).
El ciclo de vida que se necesita para realizar un sistema de información es complejo
y sigue los siguientes pasos:
❖ Investigación preliminar. Inicio del ciclo de construcción donde se realiza el estudio
de factibilidad.
❖ Análisis del sistema. Donde se identifican los participantes del sistema de
información.
❖ Diseño lógico del sistema. Es la construcción ideal del sistema de información.
❖ Diseño físico del sistema. Se codifican los programas.
❖ Prueba de sistemas. Mediante unas pruebas de simulación se constata que cumple con
los objetivos.
❖ Implantación y evaluación. Luego se instalan y se pone en funcionamiento.
2.2 Lenguajes de programación
Conjunto de instrucciones bajo una sintaxis determinada que permite resolver un problema
de procesamiento de datos, diseñado bajo algoritmos y procesos lógicos. Permite la
interacción con el computador la que finalmente ejecutará y resolverá el problema.
27
2.2.1 Instrucciones de la computadora.
Las instrucciones generalmente están representadas por verbos en inglés, pueden ser
los siguientes:
❖ Instrucciones de entrada /salida, permiten el ingreso de datos.
❖ Instrucciones aritmético-lógicas, permiten realizar todas las operaciones.
❖ Instrucciones repetitivas. Las cuales permiten repetir un número de instrucciones hasta
que se cumpla alguna condición establecida.
2.2.2 Lenguaje máquina.
Son los primeros lenguajes de programación que aparecieron y no existía código
alguno, sino se utilizaba los mismos códigos binarios que tenía el computador.
2.2.3 Lenguajes de bajo nivel.
Según Brookshear (2006) “son más sencillos que los lenguajes de máquina, el que
representa a este tipo de lenguaje es el ensamblador” (p.45). Las instrucciones son
conocidas como nemotécnicos.
Figura 11. Programa ensamblador. Fuente: Autoría propia.
Programa ensamblador, es aquel utilizan una combinación del lenguaje de máquina
con terminología en ingles con una estructura y gramática definida.
Programa fuente en
ensamblador (assembly)
Programa
ENSAMBLADOR Programa objeto en código
máquina
28
2.2.4 Lenguajes de alto nivel.
Son aquellos que utilizan verbos en inglés como comandos y están diseñados para
ser fáciles de manejar por parte de los programadores, además se debe tener en cuenta que
es independiente de la computadora, los programas son transportables.
Los lenguajes de alto nivel presentan las siguientes ventajas: el aprendizaje es
sencillo, la codificación es natural y está de acuerdo a los comandos, puede ser
modificado, se reduce su costo y se pueden transportar.
Los inconvenientes pueden ser: demora del tiempo para poner a funcionar, no
utiliza los recursos del computador y se requiere mucha memoria.
2.2.5 Traductores de lenguaje.
Traducen los programas fuente a un código de máquina, pueden ser compiladores e
interpretadores.
a) Interpretes. Cuando el lenguaje es traducido, verificado línea por línea.
Figura 12. Intérprete. Fuente: Autoría propia.
b) Compiladores. Un compilador es cuando el programa es traducido en forma total,
mostrando los errores que tuviera.
Figura 13. La compilación de programa. Fuente: Autoría propia.
Programa fuente
Intérprete
Traducción y ejecución línea a línea
Programa fuente
Compilador
Programa objeto
29
2.2.6 La compilación y sus fases.
Es la forma de traducción del código del programa obtenido a un lenguaje de
máquina, lo que da lugar a lo que llamamos programa ejecutable.
Figura 14. Fases de la compilación. Fuente: Autoría propia.
Programa fuente
Compilador
Programa objeto
Montador
Programa ejecutable en
lenguaje de máquina
30
Capítulo III
Aplicaciones principales
3.1 PSeInt
Significa Pseudocode Interpreter, intérprete de pseudocódigo. Permite desarrollar
algoritmos bajo un entorno amigable mediante una serie de objetos que permiten de
manera intuitiva construir los algoritmos y automáticamente el diagrama de flujo
respectivamente.
3.1.1 Características del Pseint.
A continuación, presentamos las siguientes características:
❖ Corresponde a ser software libre
❖ Puede sr atendido por el propio creador.
❖ Permite la comunicación para el auxilio.
❖ Mediante foros se pueden solicitar auxilios.
❖ Su traslado al código es muy sencillo.
❖ Existe el código fuente y puede ser ejecutado.
❖ Se trata de un interpretador, el archivo puede ejecutarse en cualquier momento.
31
Instalación
Figura 15. Instalación de Pseint. Fuente: Autoría propia.
a) Instalar el archivo
Al hacer doble clic se ejecuta el instalador, seguimos con la secuencia de órdenes
hasta llegar al fin de la instalación.
b) Apuntes preliminares
Al inicio de la programación, debemos de revisar el manual de operaciones de
este software, el cual facilitara la construcción de los algoritmos. Al ingresar por
primera vez al PSeInt nos pregunta que perfil se desea emplear, y no tener
dificultades con los códigos.
c)Abrir PSeInt
Dar doble clic al icono que representa a este software, encontrado en el escritorio.
32
Figura 16. Abrir Pseint. Fuente: Autoría propia.
Figura 17. Ventana de Pseint abierta. Fuente: Autoría propia.
d)Escribir mi primer programa
Al iniciar a generar el seudocódigo, buscamos los comandos más adecuados en
nuestra codificación y entre las dos líneas, la primera que dice Inicio sin_titulo y la
33
segunda dice fin_proceso, entre esas dos líneas es donde debemos realizar el código.
Figura 18. Ingreso de sintaxis. Fuente: Autoría propia.
Luego lo guardamos.
Figura 19. Guardar archivo. Fuente: Autoría propia.
Escribimos el nombre del programa en la ventana que aparece y luego presionamos
guardar Como...
34
Figura 20. Ventana para guardar. Fuente: Autoría propia.
Luego de guardar, tenemos que ejecutar lo que codificamos y los hacemos con el
siguiente icono:
Figura 21. Ícono de ejecutar. Fuente: Autoría propia.
Si la ejecución ha sido correcta, se presenta un mensaje indicando que el programa
se ejecutó correctamente, si no es así aparece una serie de líneas indicando donde esta
nuestro error, las cuales deben ser corregidas.
35
Figura 22. Ventana de ejecución finalizada. Fuente: Autoría propia.
3.2 DFD
Software que de igual manera que el Pseint está creado con el fin.
a) Inicio
Al abrir el Dfd se ve en la pantalla la ventana de edición la cual consta de inicio y
fin ya que todo algoritmo debe tener esos pasos, escoger alguna de las herramientas que se
presentan al inicio
Figura 23. Ventana de edición. Fuente: Auditoría propia.
36
Figura 24. Barra de herramientas. Fuente: Autoría propia.
Ejercicio: Ingresar la edad de una persona y luego le responderá cuantos años tiene,
se usarán objetos como salidas y lectura.
Abrir el programa (Dfd) y agregamos una salida.
Figura 25. Abriendo programa DFD. Fuente: Autoría propia.
Damos doble clic y escribimos entre comillas simples (‘Ingrese su edad en números
y presione el botón enter’).
37
Figura 26. Ingreso de edad en números. Fuente: Autoría propia.
Ahora agregamos una lectura.
Figura 27. Agregamos una lectura. Fuente: Autoría propia.
Dar clic y escribimos las variables, no poner las comillas.
38
Figura 28. Ingreso de edad. Fuente: Autoría propia.
Agregamos una nueva salida.
Figura 29. Agregamos nueva salida. Fuente: Autoría propia.
Doble clic y respondemos a la interrogante. La variable no debe tener comillas y
debe estar separada por comas. ('su edad es de ', edad,' años').
39
Figura 30. Ingreso de edad en años. Fuente: Autoría propia.
Ya terminado el algoritmo tendrá la siguiente forma en la pantalla.
Figura 31. Pantalla final de un algoritmo. Fuente: Autoría propia.
Cuando el algoritmo finaliza su ejecución y no tiene errores se muestra el siguiente
mensaje:
40
Figura 32. Ejecución de algoritmo finalizada. Fuente: Autoría propia.
3.3 Java Netbeans
Es un programa que permite realizar seudocódigo, el cual puede ser convertido a código
real, es un software libre y está hecho en base al Java:
❖ Accesando a directorios en Netbeans 3.6
Ingresar al Netbeans dando un clic derecho o seleccionando el menú file,
seleccionando local directory, archive files o versión control.
❖ Creación y edición de código en java con Netbeans.
Netbeans contiene templates y wizards.
❖ Edición de código en java con Netbeans.
Como herramienta tenemos al editor. Al abrir un código en java dar clic en el file que
se encuentra en el archivo filesystems. Cuando ingresamos al editor vemos:
Figura 33. Edición de código en java con Netbeans. Fuente: Autoría propia.
41
Para dar inicio a una aplicación de Java bajo el entorno de Netbeans se debe definir
un proyecto, para ello, seleccionas la opción del menú denominada File. Se muestra
inmediatamente un menú flotante cuya primera opción indica New Proyect, está opción la
seleccionas.
Figura 34. Definición de proyecto. Fuente: Autoría propia.
Al momento de seleccionar New Proyect se visualiza la ventana siguiente:
Figura 35. Visualización de New Proyect. Fuente: Autoría propia.
42
Como nuestras aplicaciones son de tipo consola, seleccionar en categorías la carpeta
Java y en proyectos seleccionar Java Application.
Luego hacer click en el botón de comando Next que mostrará la siguiente ventana:
Figura 36. Ventana Java Application. Fuente: Autoría propia.
Se debe crear una carpeta de destino donde se almacenen los programas, debemos
de realizar los siguientes pasos:
Figura 37. Selección de proyecto. Fuente: Autoría propia.
43
Figura 38. Carpeta nueva. Fuente: Autoría propia.
Ya indicada EjerciciosDeNetBeans, clic en el botón de comando Abrir y New Java
Application quedara como:
Figura 39. New Java Application. Fuente: Autoría propia.
44
Proyect Location muestra la carpeta destino del proyecto. Realizamos un programa
que calcule dado dos notas el promedio, debe quedar como vemos:
Figura 40. Nombre del proyecto. Fuente: Autoría propia.
Clic en Finish y se muestra el entorno de desarrollo NetBeans y construir la aplicación
Figura 41. Desarrollo de NetBeans. Fuente: Autoría propia.
45
Podemos a elaborar el ejercicio, pero debemos conocer la estructura de la clase
principal.
Figura 42. Inicio para la construcción en Netbeans. Fuente: Autoría propia.
46
Aplicación didáctica
Sesión de aprendizaje
Título: Herramientas de algoritmos
I. DATOS INFORMATIVOS:
Institución educativa:
Componente :
Grado y sección : 4to. de secundaria
Duración : 45 minutos
Fecha :
Profesor : Pezo Zuta, Jaime
II. LOGRO DE APRENDIZAJE DE LA SESIÓN:
Define y reconoce las herramientas del algoritmo
III. ORGANIZACIÓN DE LOS APRENDIZAJES:
Conocimientos Capacidades Actitudes
Desarrollo de un algoritmo con
PSEINT.
Solución de un problema de
proceso de datos con el
Software PSEINT
Razonamiento y
demostración
- Identifica datos y analiza
sus relaciones
- Representa e interpreta
los datos en el diagrama
de flujo.
- Muestra seguridad y
perseverancia al resolver
problemas y comunicar
resultados.
- Toma la iniciativa para
formular preguntas
- Perseverancia en la
búsqueda de soluciones.
- Valora aprendizajes
desarrollados en el área
como parte de su proceso
formativo.
IV. SECUENCIA DIDÁCTICA:
Estrategias
metodológicas
Evaluación
T Situación de
aprendizaje
Intervención
didáctica
Actividad de
aprendizaje
Recursos
didácticos
Indicador Toma
iniciativa
5
Inicio
Grupos
cooperantes
Motivación
Me presento, para
comenzar con el
tema los alumnos
Computador
Proyector
multimedia
Actitud
ante el
área
Toma la
iniciativa
para
47
Exposición de
ideas
haciendo un repaso
de los temas
anteriores, a cada
alumno se le
entrega una ficha
con el problema
que consiste en:
Calcular la suma de
dos números
naturales.
De esta manera se
permite al alumno
prepararse para
comenzar con la
clase.
Pizarra
Plumones
Computador
formular
preguntas.
40
10
Proceso
Salida
Culminando el
inicio, se procederá
a desarrollar un
breve resumen del
tema (herramientas
de programación),
con participación
de los alumnos, se
plantea desarrollar
un algoritmo para
hallar la solución
empleando la idea
de algoritmos.
Realizan el
algoritmo y lo
plasman en código
en el Software
PSEINT.
Ejecutan el
programa y
comprueban los
resultados del
algoritmo.
Trabajan una hoja de
práctica.
Evaluación
Ficha de
observación
Guía de
laboratorio
48
Guía de laboratorio: PSEINT DFD
Apellidos y nombres: ……………………………………………………………….
Profesor: Pezo Zuta, Jaime
Fecha: …….
Ejercicio: Aplicaremos el programa PSEINT para hallar promedios con números enteros.
Desarrollo de la práctica:
1. Enciende la computadora y espera a que aparezca el Escritorio de Windows.
2. Abra el programa Pseint que aparece en el escritorio).
3. Aparecerá la ventana del programa, la cual se detalla a continuación:
49
Empezaremos a digitar lo siguiente considerando que queremos sacar promedios de
alumnos con 3 notas básicas:
a) Colocamos un título como: NOTADEALUMNO
b) ESCRIBIMOS: Definir a,b,c, Como Enteros
c) ESCRIBIMOS: Difinir d Como Real
d) ESCRIBIMOS: Escribir “ingresar nota1 del alumno”;
e) ESCRIBIMOS: Leer a;
f) ESCRIBIMOS: Escribir “ingresar nota2 del alumno”;
g) ESCRIBIMOS: Leer b;
h) ESCRIBIMOS: Escribir “ingresar nota3 del alumno”;
i) ESCRIBIMOS: Leer c;
j) Luego establecemos lo siguiente escribiendo: d(a+b+c)/3
k) Luego escribimos: Escribir “el promedio es:”,d;
50
4. Luego hacemos clic en el icono color verde que significa ejecutar y podremos
visualizar la siguiente ventana
Nota: Si hay errores al ejecutar, el símbolo donde hay error se pondrá una cruz + color
Rojo, corríjalos y vuelva a ejecutar.
Luego si no hay errores digitaremos las siguientes notas en la ventana que aparece
15 enter 16 enter y 17 enter y tendremos un resultado con el promedio solicitado, este
seudocódigo lo podremos insertar a un determinado lenguaje de programación que nos
permitirá tener un programa de notas.
51
5. Y luego, podemos hacer clic en el icono de DFD o de diagrama de flujo para ver una
presentación grafica del Pseint y quedara de la siguiente forma:
resultados de la ejecución del DFD.
52
Síntesis
Algoritmo deriva de la alkhowarizmi, siendo este el nombre de un matemático árabe y
astrónomo del sigo IX cuya obra trata sobre la manipulación de números y ecuaciones
mediante procesos continuos hasta resolverlos.
También, podemos definir a los algoritmos es una serie de pasos los cuales dan
solución a un problema específico. Los algoritmos deben cumplir con algunas
características fundamentales como el que debe tener un valor finito de pasos, ósea tiene
un inicio y un término. De acuerdo al sistema operativo vemos que los algoritmos no
cambian sino se adaptan. Los algoritmos pueden ser representados en forma gráfica como
los flujogramas y en forma literal como son los seudocódigos.
Los flujogramas o diagramas de flujo están presentados por una serie de figuras que
representan alguna acción. Es una representación gráfica de un pseudocódigo. Los
seudocódigos representan la parte literal y son el lenguaje natural del usuario, los cuales
son presentados con algunas características importantes entre encontramos.
53
Apreciación crítica y sugerencias
Sabemos hoy en día, que en nuestro país se apuesta muy poco o nada por la investigación,
por ello espero que esta monografía despierte y motive el afán por el deseo de la
investigación. El mundo de la informática, específicamente de la programación es tan
complejo que lo que hemos desarrollado se vuelve tan pequeño con relación a lo que resta.
La introducción a la programación, es idóneo en el estudio y definición de las
estructuras de datos manejable para aquel que estudia y que deseen ser programadores. Su
finalidad es dar una buena base para aquellos estudiantes que deseen sumergirse en el
campo de la programación, es por eso que lo convirtieron en el conocimiento ideal para
aquellos que dan sus primeros pasos en programación, en el ámbito de nuestro país solo se
utiliza en las universidades, institutos tecnológicos y algunos colegios privados.
A manera de sugerencia la universidad pueda seguir al Ministerio de Educación para
que el Currículo Nacional, pueda considerar el aprendizaje en los alumnos el uso de
lenguajes de programación, ya que facilitaría el desarrollo mental sobre todo conocer la
inteligencia artificial que es la computadora, por ser el Alma Máter de la educación peruana.
54
Referencias
Brena, R. (2016). Lenguajes Formales y Autómatas. México: Centro de Inteligencia
Artificial, Instituto Tecnológico y de Estudios Superiores de Monterrey.
Brookshear, J., y Glenn, J., (2006). Teoría de la Computación, Lenguajes formales,
Autómatas y Complejidad. Addison, Estados Unidos: Wesley Iberoamericana.
Bueno, C. (2008). Uso de los objetos del programa DFD. Colombia: Universidad
Tecnológica de Pereira.
Carrasco, J. (2001). Programación con Visual Basic. Perú: Editorial Universitaria.
Castañeda; J. (2005). Diseño de programación. Perú: San Marcos.
Corona, M., y Ancona, M., (2008). Diseño de Algoritmos y su codificación en Lenguaje C.
España: Mc Graw Hill.
Galve, J., (1993). Algorítmica: diseño y análisis de algoritmos funcionales e imperativos.
España: RA-MA.
Informática. Recuperado el 14 de julio del 2019 de: http://www.mailxmail.com/curso-
holistica-informatica/informatica-aplicaciones-computacionales
Joyanes, L. (2012). Fundamentos de programación. España: McGraw-Hill/Interamericana
de España, S. A. U.
Joyanes, L. (2008). Algoritmos y estructura de datos. España: McGraw-
Hill/Interamericana de España, S. A. U.
Knuth, D. (2004). Algoritmos fundamentales. España: Reverte S. A.
Lenguaje de programación. Recuperado el 14 de julio del 2019 de:
http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n
López, S. (2015). Manual y programación en Pseint. Colombia: Toro.
Monreal, J. (2008). El mundo de la computación Tomo 3 y 4. Barcelona, España: Océano.
55
Tremblay, J., & Bunt, R.; (2001). Introducción a las ciencias de las computadoras.
EE.UU: Mac Graw-Hill.