miércoles, 26 de octubre de 2016

6.Arreglos

ARREGLOS UNIDIMENSIONALES
Un arreglo unidimensional es un tipo de datos estructurado que está formado por una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales. Los datos que se guarden en los arreglos todos deben ser del mismo tipo.


El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria.

Los arreglos nos permiten hacer un conjunto de operaciones para manipular los datos guardados en ellos, estas operaciones son: ordenar, buscar, insertar, eliminar, modificar entre otras.


REPRESENTACIÓN EN MEMORIA: Los arreglos guardan en memoria la cantidad de espacios que se le indican en la declaración.



Ejercicios:

1) Crea un array o arreglo unidimensional con un tamaño de 5, asignale los valores numéricos manualmente (los que tu quieras) y muestralos por pantalla.

Pseudocodigo:
Proceso Ejercicio1
 
 //Declaramos variables
 Definir num como entero;
 Definir TAMANIO como entero;
 TAMANIO<-5
 //Definimos el array
 Dimension num[TAMANIO]
 
 //Asignamos valores 
 num[1]<-1
 num[2]<-2
 num[3]<-3 
 num[4]<-4
 num[5]<-5  
 
 //Recorremos el array y mostramos su contenido
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer 
  escribir num[i] 
 Fin Para  
 
FinProceso
Diagrama de Flujo:

2) Modifica el ejercicio anterior para que insertes los valores numéricos con leer mediante un bucle y los muestre por pantalla.
Pseudocodigo:
Proceso Ejercicio2 
 
 //Declaramos variables 
 Definir num como entero 
 
 Definir TAMANIO como entero; 
 TAMANIO<-5; 
 
 //Definimos el array 
 Dimension num[TAMANIO]
 
 //Introducimos valores
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  Escribir "Introduce un valor para la posición ",i  
  leer num[i]
 Fin Para 
 
 //Recorremos el array y mostramos su contenido
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  escribir num[i]
 FinPara
 
FinProceso
Diagrama de Flujo:


3) Crea un array o arreglo unidimensional con un tamaño de 10, inserta los valores numéricos que desees de la manera que quieras y muestra por pantalla la media de valores del array.
Pseudocodigo:
Proceso Ejercicio3 
 
 //Declaramos variables 
 Definir num como entero
 Definir TAMANIO como entero
 Definir suma Como Entero
 TAMANIO<-10
 
 //Definimos el array
 Dimension num[TAMANIO]
 
 //Introducimos valores
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  Escribir "Introduce un valor para la posición ",i  
  leer num[i]
 Fin Para 
 
 //Recorremos el array, sumando su contenido 
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  suma<-suma+num[i]
 FinPara
 
FinProceso
Diagrama de Flujo:

4) Crea un array o arreglo unidimensional donde tu le indiques el tamaño por teclado y crear una función que rellene el array o arreglo con los múltiplos de un numero pedido por teclado. Por ejemplo, si defino un array de tamaño 5 y eligo un 3 en la función, el array contendrá 3, 6, 9, 12, 15. Muestralos por pantalla usando otra función distinta.
Pseudocodigo:
SubProceso asignaValores ( num, TAMANIO, num_multiplo )
 
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  num[i]<-num_multiplo*i
 Fin Para
Fin SubProceso

SubProceso  mostrarArray ( num, TAMANIO ) 
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  escribir num[i]
 Fin Para
Fin SubProceso

Proceso Ejercicio4
 
 //La creacion de subprocesos es totalmente opcional
 
 //Declaramos variables
 Definir num como entero
 Definir TAMANIO como entero
 Definir suma Como Entero
 definir num_multiplo como entero
 
 //Definimos el tamaño del array por teclado 
 escribir "Introduce el tamaño del array"
 leer TAMANIO
 
 //Definimos el array
 Dimension num[TAMANIO]
 
 //Definimos el numero con el que rellenaremos el array con sus multiplos
 escribir "Introduce el numero con el que rellenar" 
 leer num_multiplo
 
 //invocamos a las funciones
 asignaValores(num, TAMANIO, num_multiplo)
 mostrarArray(num, TAMANIO)
 
FinProceso
Diagrama de Flujo:

5) Crea dos arrays o arreglos unidimensionales que tengan el mismo tamaño (lo pedirá por teclado), en uno de ellos almacenaras nombres de personas como cadenas, en el otro array o arreglo ira almacenando la longitud de los nombres, para ello puedes usar la función LONGITUD(cadena) que viene en PseInt. Muestra por pantalla el nombre y la longitud que tiene. Puedes usar funciones si lo deseas.
Pseudocodigo:
SubProceso  mostrarArrays ( longitud_nombres, nombres, TAMANIO )
 
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  escribir "La longitud del nombre ",nombres[i]," es de ",longitud_nombres[i]
 Fin Para
 
Fin SubProceso

Proceso Ejercicio5 
 
 //Declaramos variables 
 Definir longitud_nombres como entero
 Definir nombres como cadena
 Definir TAMANIO como entero
 
 //Definimos el tamaño del array por teclado 
 escribir "Introduce el tamaño de los arrays"
 leer TAMANIO 
 
 //Definimos el array 
 Dimension longitud_nombres[TAMANIO]
 Dimension nombres[TAMANIO]
 
 //Introducimos los nombres y la longitud de los mismos
 Para i<-1 Hasta TAMANIO Con Paso 1 Hacer
  escribir "Introduce un nombre para la posicion ",i  
  leer nombres[i]
  longitud_nombres[i]<-Longitud(nombres[i])
 Fin Para 
 
 //Invocamos la función
 mostrarArrays(longitud_nombres, nombres, TAMANIO)
 
FinProceso
Diagrama de Flujo:

Arreglos bidimensionales:
Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo bidimensional está simultáneamente en una fila y en una columna.
En matemáticas, a los arreglos bidimensionales se les llama matrices, y son muy utilizados en problemas de Ingeniería.
En un arreglo bidimensional, cada elemento tiene una posición que se identifica mediante dos índices: el de su fila y el de su columna.
Ejemplos:
1) Crear una matriz de n filas y n columnas, llenar la matriz con los números que el usuario desee:
Pseudocodigo:
Proceso arreglos
Definir j,i,num,f,c,dat Como Entero;
Escribir 'digite el numero de filas';
Leer f;
Escribir ' digite el numero de columnas';
Leer c;
Dimension mat[4,8];
Para i<-1 Hasta f Hacer
Para j<-1 Hasta c Hacer
Escribir ' digite dato para la fila';
Leer dato;
mat[i,j]<-num;
FinPara
FinPara
Para i<-1 Hasta f Hacer
Para j<-1 Hasta c Hacer
Escribir 'los datos que hay en la matriz son',mat[i,j];
FinPara
FinPara
FinProceso
Diagrama de Flujo:

2) Llenar una matriz de 3*3 completamente de numeros aleatorios  entre 0 y 9
Pseudocodigo:
Proceso arreglo Definir i,j,matriz Como Entero; Para j<-1 Hasta 3 Con Paso 3 Hacer Para j<-1 Hasta 3 Hacer matriz[i,j]<- azar (10); FinPara FinPara Para i<-1 Hasta 3 Hacer Escribir matriz,(i,j),' ',matriz[1,2],' ',matriz[1,3]; FinPara FinProceso
Diagrama de Flujo:


3) Crear una matriz n x n y llenarla con los números que el usuario desee. Sume
todos los números que componga la columna 1.
Pseudocodigo:
Proceso ARREGLOS
 Definir x,j,fila,colum,matriz Como Entero;
 acum <- 0;
 Escribir 'inserte el numero de filas';
 Leer filas;
 Escribir 'digite el numero de columna';
 Leer colum;
 Dimension matriz[fila,colum];
 Para i<-1 Hasta fila Hacer
  Para x<-1 Hasta colum Hacer
   Escribir 'digite dato para la fila',i;
   Escribir 'digite la  columna',j;
   Leer n;
  FinPara
 FinPara
 Para i<-1 Hasta fila Hacer
  Para x<-0 Hasta colum Hacer
   Escribir matriz,(i,x);
  FinPara
 FinPara
 Escribir 'todos los elementos de l columna 1 suman',acum;
FinProceso

Diagrama de Flujo:


 

martes, 25 de octubre de 2016

1.- Resolución de problemas empleando computadoras

Resolución de problemas por computadoras
La principal razón para que las personas aprendan lenguajes de programación es utilizar un ordenador como una herramienta para la resolución de problemas. Tres fases pueden ser identificadas en el proceso de resolución :
 - Fase de Identificación (qué nos plantean)
 - Fase de resolución del problema
 - Fase de implementación (realización) en un lenguaje de programación
 Fase de resolución del problema:

Esta fase incluye, a su vez, el análisis del problema así como el diseño y posterior verificación del algoritmo. 
Definición del problema.- Es el enunciado del problema, el cual debe ser claro y completo. Es fundamental conocer y delimitar por completo el problema, saber que es lo que se desea que realice la computadora, mientras esto no se conozca del todo, no tiene caso continuar con el siguiente paso.

Análisis del problema .- El primer paso para encontrar la solución a un problema es el análisis del mismo. Se debe examinar cuidadosamente el problema a fin de obtener una idea clara sobre lo que se solicita y determinar los datos necesarios para conseguirlo. 

Diseño del algoritmo.- Un algoritmo puede ser definido como la secuencia ordenada de pasos, sin ambigüedades, que conducen a la resolución de un problema dado y expresado en lenguaje natural, por ejemplo el castellano, Todo algoritmo debe ser: 
  •  Preciso: Indicando el orden de realización de cada uno de los pasos. 
  • Definido: Si se sigue el algoritmo varias veces proporcionándole ( consistente ) los mismos datos, se deben obtener siempre los mismos resultados. 
  • Finito: Al seguir el algoritmo, este debe terminar en algún momento, es decir tener un número finito de pasos. 
Para diseñar un algoritmo se debe comenzar por identificar las tareas más importantes para resolver el problema y disponerlas en el orden en el que han de ser ejecutadas. Los pasos en esta primera descripción pueden requerir una revisión adicional antes de que podamos obtener un algoritmo claro, preciso y completo. 
Este método de diseño de algoritmos en etapas, yendo de los conceptos generales a los de detalle, se conoce como método descendente (top-down). 
En un algoritmo se deben de considerar tres partes:
  •  Entrada: Información dada al algoritmo. 
  • Proceso: Operaciones o cálculos necesarios para encontrar la solución del problema. 
  • Salida: Respuestas dadas por el algoritmo o resultados finales de los procesos realizados. Como ejemplo supongamos que desea desarrollar un algoritmo que calcule la superficie de un rectángulo proporcionándole su base y altura. Lo primero que debemos hacer es plantearnos las siguientes preguntas: 

¿Que datos son de entrada? 
¿Cuántos datos se introducirán? 
¿Cuántos son datos de entrada válidos?

 Especificaciones de salida:

¿Cuáles son los datos de salida? 
¿Cuántos datos de salida se producirán? 
¿Qué formato y precisión tendrán los resultados? 

El algoritmo que podemos utilizar es el siguiente: 

Paso 1. Entrada desde el teclado, de los datos de base y altura. 
Paso 2. Cálculo de la superficie, multiplicando la base por la altura. 
Paso 3. Salida por pantalla de base, altura y superficie calculada. 

El lenguaje algorítmico debe ser independiente de cualquier lenguaje de programación particular, pero fácilmente traducible a cada uno de ellos. Alcanzar estos objetivos conducirá al empleo de métodos normalizados para la representación de algoritmos, tales como los diagrama de flujo o pseudocódigo. 

Verificación de algoritmos.-  Una vez que se ha terminado de escribir un algoritmo es necesario comprobar que realiza las tareas para las que se ha diseñado y produce el resultado correcto y esperado. El modo más normal de comprobar un algoritmo es mediante su ejecución manual, usando datos significativos que abarquen todo el posible rango de valores y anotando en una hoja de papel las modificaciones que se den estos datos y en los del resto del algoritmo, en las diferentes fases hasta la obtención de los resultados. Este proceso se conoce como prueba del algoritmo.

Fase de implementación :

Una vez que el algoritmo está diseñado, representado mediante pseudocódigo y verificado se debe pasar a la fase de codificación o traducción del algoritmo a un determinado lenguaje de programación, que deberá ser completada con la ejecución y comprobación del programa en el ordenador
Codificación del algoritmo.- Codificar es escribir el algoritmo representado mediante una herramienta de programación en un lenguaje de programación 
Para realizar la conversión del algoritmo en programa se deben sustituir los símbolos utilizados por las correspondientes palabras reservadas del lenguaje, y las operaciones/instrucciones expresarlas en el lenguaje de programación correspondiente.

Compilación y ejecución del programa.-Una vez que el algoritmo se ha convertido en un programa fuente, es preciso introducirlo en memoria mediante el teclado y almacenarlo posteriormente en un disco. Esta operación se realiza con un programa editor, posteriormente el programa fuente se convierte en un archivo de programa que se guarda en un disco.

El programa fuente debe ser traducido a lenguaje de máquina. Este proceso se realiza con el compilador y el sistema operativo que se encarga prácticamente de la compilación. Si tras la compilación se presentan errores en el programa fuente, es preciso volver a editar el programa, corregir los errores y compilar de nuevo. Este proceso se repite hasta que no se producen errores, obteniéndose entonces el programa objeto. Luego se realizará la fase de montaje del programa objeto con las librerías del programa del compilador. El proceso de montaje produce un programa ejecutable.
Cuando el programa ejecutable se ha creado, se lo puede ejecutar desde el sistema operativo con solo teclear su nombre. Suponiendo que no existan errores durante la ejecución (llamados errores de ejecución), se obtendrá la salida de resultados del programa.

Verificación y depuración del programa.-La verificación de un programa es el proceso de ejecutar el programa con varios datos de entrada llamados datos de prueba, que determinarán si el programa tiene errores.
La depuración es el proceso de encontrar los errores del programa y corregir o eliminar dichos errores.
Documentación y mantenimiento.-
La documentación de un problema consta de las descripciones de los pasos a dar en el proceso de resolución de un problema. Debe ser realizada con mucho cuidado y detalle por la influencia que tiene en el producto final. Programas pobremente documentados son difíciles de leer, más difíciles de depurar y casi imposibles de mantener y modificar.
La documentación de un programa puede ser interna o externa. La documentación interna es la contenida en las líneas de comentarios. La documentación externa incluye análisis, diagramas de flujo y/o pseudocódigo, manuales de usuario con instrucciones para ejecutar el programa y para interpretar los resultados.
La documentación es vital cuando se desea corregir posibles errores futuros o bien cambiar el programa. Tales cambios se denominan MANTENIMIENTO DEL PROGRAMA. Después de cada cambio la documentación debe ser actualizada para facilitar cambios posteriores. Es práctica numerar las sucesivas versiones de los programas 1.0, 1.1, 2.0, 2.1, 2.2, 3.0, etc. (Si los cambios introducidos son importantes se varía el primer dígito Ej. de 1.0 a 2.0; en caso de cambios pequeños sólo se varía el segundo dígito Ej. de 2.0 a 2.1).

2.¿Cual es el propósito del análisis del problema?

Definición del problema:

Requiere que el problema sea definido y comprendido claramente para que pueda ser analizado con todo detalle.

El propósito del análisis del problema es ayudar al programador para llegar a una cierta comprensión de la naturaleza del problema. El problema debe estar bien definido si se desea llegar a una solución satisfactoria.
Para poder definir con presicion  el problema se requiere que las especificaciones de entrada, proceso y salida sean descritas con detalles.

  • Entrada.- Son todos los datos que hay que ingresar para la resolución del problema.
  • Proceso.- Son los diferentes procedimientos en los cuales usare los datos proporcionados por el usuario en el paso anterior para resolver el problema.
  • Salida.- La resolución del problema.

Una buena definición del problema, junto con una descripción detallada de las especificaciones de entrada y salida, son los requisitos mas importantes para llegar a una solución eficaz
El análisis del problema exige una lectura previa del problema a  fin de obtener una idea general de lo que se solicita.

3.¿Cuales son las características de un buen algoritmo?

  • Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.
  • Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo resultado cada vez.
  • Un algoritmo debe ser finito. el algoritmo se debe terminar en algún momento; o sea, debe tener un número finito de pasos.
  •  Un algoritmo debe ser legibles: El texto que lo describe debe ser claro, tal que permita entenderlo y leerlo fácilmente.
  • Un algoritmo debe definir tres partes: Entrada, Proceso y SalidaEjemplo: el algoritmo de receta de cocina se tendrá:Entrada: ingrediente y utensilios.Proceso: elaboración de la receta en la cocina.Salida: terminación del plato (por ejemplo, Pollo al horno)

4.-Diseño de un algoritmo

Diseño descendente o Top-Down:

También conocida como de arriba-abajo (diseño descendente) y consiste en establecer una serie de niveles de mayor a menor complejidad (arriba-abajo).  Consiste en efectuar una relación entre las etapas de la estructuración de forma que una etapa jerárquica y su inmediato inferior se relacionen mediante entradas y salidas de información. Este diseño consiste en una serie de descomposiciones sucesivas del problema inicial, que recibe el refinamiento progresivo del repertorio de instrucciones que van a formar parte del programa. La utilización de la técnica de diseño Top-Down tiene los siguientes objetivos básicos: Simplificación del problema y de los subprogramas de cada descomposición. Las diferentes partes del problema pueden ser programadas de modo independiente e incluso por diferentes personas. 
El programa final queda estructurado en forma de bloque o módulos lo que hace mas sencilla su lectura y mantenimiento. 

Ejemplo:
Queremos saber como se estructura nuestro planeta con el metodo Top-Down




En este ejemplo podemos apreciar la forma en que desciende desde el punto mas amplio del problema y poco a poco descomponiéndose en pequeñas partes haciendo mas entendible el caso.




Divide y venceras
Divide y Vencerás es una técnica de diseño de algoritmos que consiste en resolver un problema a partir de la solución de subproblemas del mismo tipo, pero de menor tamaño. Si los subproblemas son todavía relativamente grandes se aplicará de nuevo esta técnica hasta alcanzar subproblemas lo suficientemente pequeños para ser solucionados directamente. Ello naturalmente sugiere el uso de la recursión en las implementaciones de estos algoritmos
La primera linea se desprende de un top-dawn en una cadena de subproblemas :


REFINAMIENTO POR PASOS:

El diseño de un algoritmo no se hace de una sola vez, sino que se va resolviendo en una secuencia de pasos (llamados pasos de refinamiento).
En cada paso el problema es refinado agregando detalles significativos, por lo que el método se conoce como: método de los refinamientos sucesivos.
Como es natural, dependiendo de la complejidad del problema se necesitaran diferentes y sucesivos niveles de refinamiento antes de que pueda obtenerse un algoritmo con suficiente nivel de detalle. 


Ejemplo: El problema del cálculo de la circunferencia y superficie de un círculo se puede descomponer en sub problemas más simples: leer datos de entrada, calcular superficie y longitud, y escribir resultados.



Herramientas de representación:

DIAGRAMAS DE FLUJO:


Un diagrama de flujo utiliza símbolos estándar en el que  cada paso del algoritmo se visualiza dentro del símbolo  y en el orden en que estos pasos se ejecutan, se indica conectándolos con flechas llamadas líneas de flujo, ya que indican el flujo lógico del algoritmo.
Ejemplo:



PSEUDOCODIGO:


El pseudocódigo es una herramienta utilizada para el diseño de programas que permite al programador expresar sus pensamientos de una forma clara utilizando su lenguaje natural y mostrando el orden de ejecución de las sentencias del programa sin ninguna ambigüedad.




DIAGRAMAS N-S:

Son una herramienta que favorece la programación estructurada y reúne características gráficas propias de diagramas de flujo y lingüísticas propias de pseudocódigos. Constan de una serie de cajas contiguas que se leerán siempre de arriba-abajo y sus estructuras lógicas son las siguientes:




 Método Warnier: 

El método se basa en el empleo de llaves de distintos tamaños que se relacionan entre sí. La representación del algoritmo se basa en los siguientes puntos:

 • Un programa se representa por un solo diagrama en la cual se engloban todas las operaciones, estas operaciones están colocadas a la derecha de la llave y en la parte izquierda se encuentra el nombre.
 • En la parte superior de la llave principal se coloca inicio. 
• En la parte inferior de la llave principal se coloca fin.

Ejemplo:







Método Jackson:

Se trata de un método de representación de programa en forma de árbol denominado diagrama arborescente de Jackson, un diagrama de Jackson consta de: 
 • Definición detallada de los datos de entrada y salida incluyendo los archivos lógicos utilizados.
 • Representación del proceso o algoritmo. 

La simbología utilizada es la siguiente 








La lectura del árbol se realiza en preorden 


  •  Situarse en la raíz (R) 
  • Recorrer el subarbol izquierdo (I) 
  • Recorrer el subarbol derecho (D) 

Ejemplo:


Método Bertini:

Al igual que Jackson, la representación de programas es en forma de árbol denominado diagrama arborescente de Bertini. 
Un diagrama de Bertini consta de:
 • Definición detallada de los datos de entrada y salida.
 • Representación del proceso o algoritmo. 

Ejemplo:










Método Tabourier:

Se trata de un método de representación de programa en forma de árbol denominado diagrama arborescente de Tabourier, 
un diagrama de Tabourier consta de :
 • Definición detallada de los datos de entrada y salida incluyendo los archivos lógicos utilizados
. • Representación del proceso o algoritmo. 

Ejemplo:





5.Cuadro comparativo de las herramientas de presentacion




lunes, 24 de octubre de 2016