Date post: | 02-Aug-2015 |
Category: |
Documents |
Upload: | mauro-rangel |
View: | 196 times |
Download: | 1 times |
Versión 2.0 del documento Actualizado el 1 de marzo 2011
ALGORITMOS Y ANALISI DE ALGORITMOS
ADRIAN GONZALEZ
MAURICIO RANGEL
ING. JOSE EGURROLA
UNIVERSIDAD COOPERATIVA DE COLOMBIA
FACULTA DE INGENIERIA
SANTA MARTA
01/03-2011
Versión 2.0 del documento Actualizado el 1 de marzo 2011
JUSTIFICACION
Este trabajo fue realizado con el fin de demostrar la importancia que tiene los algoritmos para la realización de aplicaciones computacionales, que desde que apareció ha sido y seguirá siendo una herramienta útil para dar solución a procedimientos de problemas habituales. Dando como nacimiento el análisis de algoritmos, que es la ciencia que estudia el comportamiento de los algoritmos, en otras palabras, se encarga de demostrar con hechos, cuál de todos los algoritmos propuesto para la solución de un solo problema era el más óptimo a la repuesta esperada.
Otra razón es conocer las funcionalidades de los vectores y matrices, ya que este es un tema muy importante, porque estos nos permiten implementar la forma más eficiente de almacenar datos.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
OBJETIVOS
Aclarar la definición, el funcionamiento, su utilización, características de los algoritmos.
Conocer las sentencias que harán posible la utilización de algoritmos óptimos, dejando en claro la función de cada uno de ellos y cuando utilizarlos.
Identificar cuando un algoritmo puede ser el más óptimo.
Analizar cada posible algoritmo de solución de cualquier problema dado.
Lograr a desarrollar algoritmos eficientes y eficaces.
Estudiar cada uno de los comportamientos de los algoritmos, teniendo en cuenta el tiempo de ejecución, recursos y el rendimiento.
Conocer las principales funciones de los vectores y matrices.
Analizar las definiciones y característica de los vectores y matrices.
Lograr implementar algoritmo eficiente por medio de la utilización de vectores y matrices.
Entender la diferencia entre vector y matriz.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
INTRODUCCION
En el siguiente trabajo se definirá las distintas funciones de uso, de los algoritmos para la realización de soluciones óptimas que más adelante serán aplicaciones eficientes y eficaces. Encontraremos los componentes de los algoritmos con su significado y como aplicarlos, declararemos las sentencias necesarias para desarrollar soluciones a partir de algoritmos y como poder analizar las posibles soluciones encontradas para un problema. Se mostrara la historia y características de los algoritmos, definiendo paso a paso los elementos más importantes del tema. También el comprender los distintos conceptos de vectores y matrices, dejando claro su utilización, usos, operaciones, declaraciones y sus distintas características.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
HISTORIA DE LOS ALGORITMOS
Un algoritmo es un conjunto de operaciones y procedimientos que deben seguirse para resolver un problema. La palabra algoritmo se deriva del nombre latinizado del gran Matemático Árabe Mohamed Ibn Al Kow Rizmi, el cual escribió sobre los años 800 y 825 su obra Quitad Al Mugabala, donde se recogía el sistema de numeración hindú y el concepto del cero. Fue Fibinacci, el que tradujo la obra al latín y el inicio con la palabra: Algoritmi Dicit. El lenguaje algorítmico es aquel por medio al cual se realiza un análisis previo del problema a resolver y encontrar un método que permita resolverlo. El conjunto de todas las operaciones a realizar y el orden en que se deben efectuarse, se le denomina algoritmo. Es un método para resolver un problema mediante una serie de datos precisos, definidos y finitos.
ALGORITMO: Es una secuencia finita de operaciones que resuelve un problema en un tiempo finito.
Sus características son:
Finitos: Debe acabar en algún momento. Eficientes: Deben ocupar la mínima memoria y minimizar el tiempo de ejecución. Legibles: El texto que lo describe debe ser claro, tal que permita entenderlo y leerlo
fácilmente. Modificables: Estarán diseñados de modo que sus posteriores modificaciones sean
fáciles de realizar, incluso por programadores diferentes a sus propios autores. Modulares: La filosofía utilizada para su diseño debe favorecer la división del problema
en módulos pequeños. Único punto de entrada, único punto de salida: A los algoritmos y a los módulos que
lo integran se entra por un sólo punto, inicio, y se sale por un sólo punto también, fin.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
ELEMENTOS DE UN ALGORITMO
Un algoritmos consta de datos y sentencias, estos datos son almacenados en variables las cuales son involucrados en expresiones. Las sentencias describen las acciones que pueden ser ejecutadas, en general realizan cálculos, entradas/salidas y control de flujo del algoritmo.
VARIABLES, CONSTANTES Y EXPRESIONES
Variable: Elemento del algoritmo que posee un valor, conocido por un nombre o identificador y que pertenece a un tipo de dato definido al inicio del algoritmo.
Debe ser declarada antes de usarse En un algoritmo la declaración consta de una sentencia que especifica: el tipo de dato,
su nombre y un valor inicialen algunas ocasiones.
Constante: los elementos del algoritmo que no cambian de valor a lo largo del algoritmo.
Las constantes deben ser inicializadas de acuerdo con el tipo de dato al que pertenecen
Expresión: es una combinación de variables, constantes, valores constantes, operadores y funciones especiales que, en cada momento, al evaluarla tiene un valor concreto.
Las expresiones más representativas son las numéricas y las lógicas
Las expresiones numéricas tienen como resultado datos numéricos, las operaciones entre paréntesis se evalúan primero, Las operaciones aritméticas se evalúan según el orden de prioridad.
Las expresiones lógicas son las que ofrecen como resultado después de su operación un valor lógico.Los operadores lógicos que involucran son: AND, OR, NOT y los relacionales: <, >, ==, <=, >=, ~=
TIPOS DE DATOS
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Pueden ser:
Enteros: Representan números positivos o negativos sin decimales. Reales: Almacenan un valor. Carácter: Representan elementos individuales de un conjunto finito de caracteres. Lógico o booleano: Solo pueden tener dos posibles valores verdadero o falso. Enumerado: este tipo de dato requiere que el programador defina el rango de valores
que puede tomar. Subrango: este tipo de dato se define a partir del tipo de dato entero, carácter o
enumerado, con solo decir que el tipo de dato definido podrá tomar un conjunto de valores limitado del original.
Puntero: es aquel cuyo valor es la dirección en memoria de otro dato.
Datos estructurados
Registros: formada por varios elementos o campos que se refieren a una misma entidad, es heterogénea, estática y de acceso por nombre.
Lista: es una estructura de datos homogéneos, dinámicos y de acceso por clave. Se constituye por una cantidad no prefijada de registros, con al menos dos campos, uno de los cuales sirve para localizar al sgte. Elemento de la lista.
Árbol: es una estructura de datos homogénea y dinámica que ordena los elementos que la integran en forma de árbol, usando nodos y subárboles
Array: es una estructura de datos homogénea, estática y ordenada, formada por una cantidad fija de datos de un mismo tipo, cada uno tiene asociado uno o más índices que determinan la posición del dato en el array.
Cadenas de caracteres: está formada por una secuencia de caracteres en un orden determinado, por lo tanto es una estructura homogénea, estática y de acceso por posición.
SENTECNCIAS
Sentencias: Describen lo que debe hacer el algoritmo. Asignación: almacena un valor en una variable o variable o constante. Se representa con el operador
Entrada/salida: Pueden almacenarse de tres formas: asociados con constantes, asignados a una variable o una sentencia de lectura.
Entrada: Leer lista de variables separadas por comas.
Salida: Escribir lista de variables o expresiones separadas por comas.
SENTENCIAS DE CONTROL DE FLUJOS DEL ALGORITMO
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Secuenciales: todas las instrucciones se ejecutan una detrás de otra:
Ejemplo: calcular el área de un triangulo
Selectivas (bifurcaciones): se evalúa una expresión lógica o relacional, y en función de su resultado se selecciona cual de las posibles opciones se toma.
Ejemplo: dados dos números imprime el mayor de ellos.
OPERADORES CONDICIONANTES
SI (CONDICION) ENTONCES ………….. …………… SI-NO ………FIN-SI
OPERADORES LOGICOS
Igual =Mayor que >Menor que <Mayor o igual >=Menor o igual <=Diferente de <>Not : negación
OPERADORES RELACIONALES
Sirven para combinar dos o más condicionantes:
1. AND: dos condicionantes talque su salida es positiva únicamente cuando ambas condiciones son positivas.
2. OR: se utiliza para combinar dos condicionantes talque su salida es falsa únicamente cuando las dos condiciones son falsas.
3. NAND: es el inverso del and.
CICLOS REPETITIVOS CUALITATIVOS
Versión 2.0 del documento Actualizado el 1 de marzo 2011
1. HAGA HASTA: procesa determinada cantidad de registro o información en general hasta que la condición se cumpla su formato es el siguiente.
HAGA HASTA (CONDICION)………………….………………….………………….FIN –HH
2. HAGA MIENTRAS: su funcionamiento consiste en que repite sus operaciones o líneas enmarcadas en el, mientras que la condición se planteada sea positiva.
HAGA MIENTRAS (CONDICION)……………………………………FIN-HM
CICLOS REPETITIVOS CUANTITATIVOS
1. FOR: su formato es el siguiente:
PARA OBJETO=[VAR INI]; OBJETO[VAR FIN]; OBJETO[INC 0 DEC]…………..…………..FIN PARA
EJEMPLOS
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Ejemplo del operador modulo
Ejemplo que muestra el promedio y muestra la utilización del ciclo para
Este ejemplo contiene líneas con distintos tipos de errores
Todos estos ejemplos fueron tomados de la herramienta PSEINT. Esta sirve para aprender la lógica de la progamacion.
ANALISIS DE ALGORITMO
Versión 2.0 del documento Actualizado el 1 de marzo 2011
El análisis de algoritmos nos permite medir la dificultad inherente de un problema y evaluar la eficiencia de un algoritmo. Como sabemos un algoritmo es la forma de resolver un problema de cualquier índole con la mejor solución posible, siendo así que para un solo problema se produce varios o muchos algoritmo dando una solución posible. Teniendo este concepto claro podemos decir que la finalidad del análisis de algoritmo, es el que nos ayuda a saber cuál de todas estas soluciones es la más eficaz y eficiente para resolver el problema, el análisis se basa en varios parámetros, uno de ellos son el tiempo de ejecución y los recursos consumidos por el algoritmo.
El análisis de algoritmo se remota del origen de las matemáticas, ya que los dos hacen estudios abstracto sin ningún tipo de implementación que rija la solución del problema. El análisis nace, para el estudio del comportamiento del algoritmo, ya que no quiere decir que si la solución es la más corta, será la solución correcta, ni viceversa. La solución más óptima será aquella que por medio de pocos recursos y menos tiempo de ejecución logre arrojar la solución más exacta a la repuesta esperada por el problema.
El análisis de algoritmos también les da una herramienta a los diseñadores de algoritmos para estimar si una solución propuesta es probable que satisfaga las restricciones de recursos de un problema.
VECTORES Y MATRICES
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Definición de Vector:
Conjunto ordenado que contiene un nº fijo de elementos (su dimensión) de cualquier
tipo válido definido con la condición de que todos deben ser del mismo tipo.
Forma de declarar un vector:
Vector tipo nombre [índice mínimo .. índice máximo]
Ejemplo: Para el ejemplo anterior la declaración del vector quedaría de esta forma:
vector entero venta [1..40]
PROPIEDADES DE LOS VECTORES Y MATRICES
1. Todos los vectores y matrices se utilizan como conectores para almacenar datos relacionados.
2. Todos los datos almacenados en vectores y matrices tienen que ser del mismo tipo. se pueden crear vectores y matrices de tipos enteros, flotantes, etc. pero en un mismo vector o matriz no se pueden mezclar los tipos de datos.
3. A los elementos almacenados en los vectores y matrices se accederá por medio de las posiciones que ocupan dentro del conjunto de los elementos de los vectores y matrices.
OPERACIONES CON VECTORES
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Asignación
En general, los lenguajes de programación incluyen como muchas instrucciones de
lectura/escritura de vectores completos, siendo muy pocos la que tienen definidas otras
operaciones primitivas con el vector tomado como dato único.
La estructura de control asociada de manera natural con los vectores es la estructura de tipo
"PARA".
Ejemplo:
Algoritmo Inicializar_Vector
Vector de reales V [1 .. 100]Para i de 1 hasta 100 hacer
V(i) 0.0Fin para
Final
En algunos lenguajes se permite la asignación directa entre vectores de igual
dimensión y tipo.
La condición principal para poder realizar este tipo de asignaciones es que debe
cumplirse que los dos vectores sean del mismo tipo y de la misma longitud.
u v el vector 'u' pasa a contener los datos de 'v'
Otra forma de hacer esta asignación es a través de la asignación de elemento en
elemento. Este tipo de asignación es la que se realiza de forma común en programación, y
la que utilizaremos en nuestros algoritmos.
Para i de 1 hasta n haceru(i) v(j)
Fin para
De este modo veamos un ejemplo: Tenemos dos vectores con las mismas
características (tipo y longitud). Se pretende intercambiar los datos entre dos vectores a
b. Para ello utilizaremos un elemento de apoyo c.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Algoritmo Intercambio de vectores Variables enteras i, n, c
Vectores de enteros a [1..100], b[1..100] Escribir “Introduzca el número de elementos de los vectores” Leer n- Para i de 1 a n Escribir “Introduzca el elemento a[“,i,”]” Leer a[i] Escribir “Introduzca el elemento b[“,i,”]” Leer b[i]- Fin_Para- Para i de 1 a n c a[i] Obsérvese como se realiza el proceso de a [i] b[i] intercambio. Necesitamos la variable de b [i] c apoyo para no perder por sobrescritura los datos de un vector.- Fin_Para- Para i de 1 a n Escribir “a[“,i,”]=”,a[i] Escribir “b[“,i,”]=”,b[i]- Fin_Para
Final
NECESIDAD DEL PREDIMENSIONAMIENTO POR EXCESO
Es muy importante entender que la zona de declaración de variables de un algoritmo
siempre se ejecuta antes que las sentencias del mismo. Debido a esto, es imposible colocar
una variable como dimensión de un vector o matriz. Por ello, siempre que pretendamos
manipular un número de datos escogido por el usuario, tendremos que recurrir a un
predimensionamiento por exceso, considerando un tamaño superior al que éste escogerá.
Habitualmente se puede poner 100 como dimensión por defecto, salvo casos en los que se vea
claro que sean necesarios más elementos.
LECTURA Y ESCRITURA
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Como hemos visto anteriormente, en algorítmica podemos utilizar la asignación de
forma directa o por medio de la asignación de los elementos. De igual forma a la hora
de leer podemos utilizar la lectura directa o lectura por elementos.
Ejemplo de lectura / escritura por elementos:
Para i de 1 a n hacerLeer v(i)
Fin para
Para i de 1 a n hacerEscribir v(i)
Fin para
Finalmente, decir que aunque por facilitar la comprensión de los ejemplos aquí
mostrados, se “obviarán” las operaciones de lectura y escritura realizándolas en forma directa,
los algoritmos de examen SIEMPRE deberán indicarse estas operaciones desarrolladas, es
decir, por elementos.
OPERACIONES ELEMENTALES CON VECTORES NUMÉRICOS
Suma de vectores
Algoritmo suma_vectoresConstante n= ... Forma de resolver el problema delVariable entera i predimensionamiento por excesoVectores reales a[1..n], b[1..n], c[1..n]Leer a,b LECTURA DIRECTA, NO USAR!Para i de 1 a n hacer
c(i) a(i)+b(i)Fin paraEscribir c ESCRITURA DIRECTA, NO USAR!Final
Los vectores que se suman han de ser del mismo tipo y dimensión.
ORDENACION Y BUSQUEDA
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Veamos en este apartado las operaciones comunes en el tratamiento de vectores.
Ordenación por selección
Supongamos un vector, donde parte de sus elementos están ordenados y otros
no. Los pasos a seguir para realizar la ordenación son los siguientes:
r n t d a H m z o k s c
a1 a2 ... ak-1 ak ... ... ... ai ... ... an
Elementos desordenados
a) Para realizar la ordenación por selección se hacen varios barridos del vector.
Primeramente cogemos el primer elemento del vector y lo comparamos con todos
los elementos restantes buscando aquel elemento que posea el valor más pequeño.
r n t d a H m z o k s c
a1 a2 ... ak-1 ak ... ... ... ai ... ... an
b) Una vez encontrado el elemento menor, se coloca en la posición correspondiente,
realizando un intercambio de posiciones entre el elemento que hemos comparado y
el que hemos encontrado.
a n t d r H m z o k s c
a1 a2 ... ak-1 ak ... ... ... ai ... ... an
c) Una vez ordenado el primer elemento, realizamos la misma operación con los
restantes. Finalmente el vector quedará ordenado.
a c d h k M n o r s t z
a1 a2 ... ak-1 ak ... ... ... ai ... ... an
Versión 2.0 del documento Actualizado el 1 de marzo 2011
El algoritmo de ordenación por selección es el siguiente.
Algoritmo Selecciónconstante n=...variable entera i,j,k
real x variable de apoyovector de reales a(1..n)
Leer a
Para i de 1 a n-1 hacer el ultimo 'n' ya estará ordenado.k i “k” es el índice del elemento menor a permutar
con a[i], inicialmente lo ponemos igual que iPara j de i+1 a n hacer
si a(j) < a(k) entones k j Si aparece un elemento de menor valor, fijamos
Finsi “k” a su índiceFin para
x a(i) Permutamos a[i] con a[k]a(i) a(k)a(k) x
Fin para
Escribir aFinal
Búsqueda Lineal
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Dado un vector que suponemos desordenado, localizar un elemento que tenga un valor
determinado requerirá un barrido a lo largo del mismo hasta encontrar dicho elemento.
Algoritmo búsqueda_lineal
constante n= ...
variable entera i
real x
vector de reales a(1..n)
Leer a
Leer x
y 1
mientras (a(i) x and i n) hacer
i i+1
fin mientras
si i n entonces
escribir ("Dato ";x;" Encontrado en la posición: ";i)
sino escribir ("Dato no encontrado")
finsi
Final
MATRICES.
Podemos extender el concepto de vector a estructuras con dos índices, es decir,
matrices.
De forma análoga a la utilización de un bucle, normalmente de tipo "para",en el
tratamiento de los elementos de un vector para el caso de una matriz, lógicamente, se
requerirán dos bucles compuestos.
Al igual que en el caso de vectores, todos los elementos de una matriz deben ser del
mismo tipo. Declaración:
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Matriz tipo nombre (índice fila mín..índice fila máx, índice col mín..índice col máx)
Los conceptos de vector y matriz no son sino casos particulares de una
estructura general de "p" dimensiones que denominaremos tabla.
OPERACIONES CON MATRICES.
Asignación.
Por ejemplo: inicialización a cero:
para i de 1 a m hacerpara j de 1 a n hacer
a(i,j) 0.0fin para
fin para
Definición de matriz identidad
para i de 1 a n hacerpara j de 1 a n hacer
si i=j entonces I(i,j) 1
sino I(i,j) 0finsi
fin parafin para
Asignación de valores introducidos por el usuario:
Versión 2.0 del documento Actualizado el 1 de marzo 2011
para i de 1 a m hacer
para j de 1 a n hacerleer a(i,j)
fin parafin para
Al igual que con los vectores, a efectos de simplificar los algoritmos de ejemplo,
expresaremos en ocasiones la lectura y escritura de forma abreviada (NO PERMITIDO EL
EJERCICIOS DE EXAMEN):
leer aescribir a
OPERACIONES ELEMENTALES CON MATRICES NUMÉRICAS.
SUMA DE MATRICES.
Algoritmo suma de matricesconstantes m=..., n=...variables enteras i, jmatrices reales a(1..m,1..n), b(1..m,1..n), c(1..m,1..n) leer a, bpara j de 1 a m hacer
para j de 1 a n hacerc(i,j) a(i,j) + b(i,j)
fin parafin paraescribir cFinal
Producto de una matriz por un escala
Algoritmo producto por un escalarconstantes m=..., n=...variables enteras i, jvariable real xmatrices reales a(1..m,1..n), b(1..m,1..n)leer aleer xpara i de 1 a m hacer
para j de 1 a n hacerb(i,j) x * a(i,j)
fin parafin paraescribir b
FinalProducto matricial
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Algoritmo producto matricial
constantes m=..., n=..., q=...variables enteras i, j, kmatrices reales a(1..m,1..n), b(1..n,1..q), c(1..m,1..q)
leer a, bpara i de 1 a m hacer
para j de 1 a q hacerc(i,j) 0.0para k de 1 a n hacer
c(i,j) c(i,j) + a(i,k)*b(k,j)fin para
fin parafin para
escribir cFinal
HISTORIA E INSTALACION DE NETBEANS
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Java es un lenguaje de programación orientado a objetos que comaprte gran parte de
su sintaxis con C y C++. Java es uno de los lenguajes más poderosos que existen actualmente y desde la versión 6 es un proyecto open source, por lo que tiene el soporte de toda una comunidad de programadores, además de Sun Microsystems que fueron los creadores originales. En 2005 Java se utilizaba en uno de cada cuatro proyectos, casi diez por ciento por encima de su siguiente competidor (C++) y ha seguido creciendo. Se estima que un noventa porciento de las computadoras cuentan con una máquina virtual de Java, además de que todos los celulares y una gran cantidad de dispositivos móviles también cuentan con Java.
NetBeans es un entorno de desarrollo integrado (IDE por sus siglas en inglés). Esto quiere decir que integra todas las herramientas que necesitamos para poder desarrollar. Originalmente la programación en Java era algo complicada porque Java cuenta con una enorme cantidad de librearías y funciones que era preciso aprenderse de memoria, viendo esto muchas compañías construyeron diferentes entornos de programación para facilitar la tarea del programador. Entre los más populares surgió Eclipse que reinó como el único y más importante IDE de Java durante varios años. Sun Microsystems desarrollo su propio IDE, que tenía la ventaja de que fue creado por las mismas personas que crearon Java años antes, este IDE fue NetBeans y después de varios años de desarrollo ha llegado a ser tan útil y poderoso como Eclipse o quizás un poco más.
PARA INSTALAR NETBEANS SE HACE LO SIGUIENTE
Lo primero que debemos hacer es descargar el kit de desarrollo de Java y el entorno de programación NetBeans. Podemos conseguir estas dos herramientas en el site oficial de Sun Microsystems. Dentro de la página de descargas debemos descargar el JDK con NetBeans.
Una vez que hayamos descargado el paquete debemos correr el instalador. Después de aceptar la licencia nos pregunta dónde queremos instalar y al final instala todos los componentes necesarios. Una vez terminado de instalar debemos buscar el ícono de NetBeans en el escritorio o en el menú inicio.
Corremos el programa haciendo doble click y nos lleva a la pantalla principal que es similar a esta:
Versión 2.0 del documento Actualizado el 1 de marzo 2011
PASOS PARA CREAR UN PROYECTO EN NETBEANS IDE 6.9.1
Versión 2.0 del documento Actualizado el 1 de marzo 2011
1. INICIAMOS LA APLICACIÓN Y APARECERA LA SIGUIENTE VENTANA
2. LUEGO DAMOS CLICK EN ARCHIVO Y A NUEVO PROYECTO
Versión 2.0 del documento Actualizado el 1 de marzo 2011
3. EN LA SIGUIENTE VENTANA SELECCIONAMOS JAVA APLICACIÓN
4. CLICK EN SIGUIENTE Y LE DAMOS UN NOMBRE A NUESTRO PROYECTO Y CLIC EN TERMINAR
Versión 2.0 del documento Actualizado el 1 de marzo 2011
5. Y FINALMENTE EN ESTA VENTANA PODEMOS VISUALIZAR LA APLICACIÓN YA CREADA, EN EL PANEL SUPERIOR IZQUIERDO Y EL ESPACIO DE TRABAJO EN LA PARTE CENTRAL Y LISTO
Versión 2.0 del documento Actualizado el 1 de marzo 2011
EJEMPLOS RESUELTOS
Para los siguientes ejemplos utilizamos herramientas para el desarrollo de algoritmo y aplicaciones de software. Los programas utilizados son Pseint y NetBeans 6.9.1
En algunos ejemplo se podrán apreciar los diagramas de flujo de datos, este fue realizado por la herramienta Pseint.
1. Hacer un pseudocodigo que imprima los numeros del 1 al 100.
Diagrama de flujo
2.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Algoritmo
Código realizado con java
package contador1;
/**
*
* @author Adrian Gonzalez
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
int contador = 1;
while (contador <= 100) {
System.out.println (contador);
contador = contador+1;
Versión 2.0 del documento Actualizado el 1 de marzo 2011
}
}
}
2. Hacer un pseudocodigo que imprima los numeros del 100 al 0, en ordendecreciente.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package contador2;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) { int contador = 100;
while (contador >= 0) { System.out.println (contador); contador = contador-1; }
}
}
3.-Hacer un pseudocodigo que imprima los numeros pares entre 0 y 100.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package pares;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) {
Versión 2.0 del documento Actualizado el 1 de marzo 2011
int contador = 2;
while (contador <= 100) { System.out.println (contador); contador = contador+2; }
}
}
4.-Hacer un programa que imprima la suma de los 100 primeros numeros.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package suma;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) { int contador = 1,suma = 0;
while (contador <= 100) { suma= suma+contador; System.out.println (contador); contador = contador+1; } System.out.println ("la suma de los 100 primeros numero es: "+suma); }}
5.-Hacer un pseudocódigo que imprima los numeros impares hasta el 100 y que
imprima cuantos impares hay.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package impares;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) { int contador = 0,i = 1;
while (i < 100) { System.out.println (i); i = i+2; contador = contador+1; } System.out.println ("hay "+ contador+" numeros impares"); }
}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
6.-Hacer un pseudocodigo que imprima todos los números naturales que hay.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package natural;import java.io.*;/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { int i=0,numero=0;
BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese un numero"); String tex = obj.readLine(); numero = Integer.parseInt(tex);
while (i< numero) { i = i+1; System.out.println(i); }
}
}
7.-Introducir tantas frases como queramos y contarlas.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { String decicion="s",frases=""; int contador = 0;
while ((decicion == null ? "s" == null : decicion.equals("s"))|(decicion == null ? "S" == null : decicion.equals("S"))){ BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese una frase"); frases = obj.readLine();
contador=contador+1; System.out.println("Presione (S) para ingresar otra frase o solamente enter para salir"); decicion = obj.readLine(); } System.out.println("El numero de frases escritas es: "+contador); }
}
8.-Hacer un pseudocodigo que solo nos permita introducir S o N.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package son;
import java.io.*;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { String decicion = "";
while (!decicion.equals("s") && !decicion.equals("n")) { BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese s o n"); decicion = obj.readLine(); } }}
9.-Introducir un numero por teclado. Que nos diga si es positivo o negativo.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package Clase_negativa_positiva;import java.io.*;public class Main { public static void main(String[] args)throws IOException { InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); System.out.println("DIGITE EL NUMERO A CALCULAR "); String texto=br.readLine();
int numero=Integer.parseInt(texto);
if(numero<0){ System.out.println("EL NUMERO INGRESADO ES NEGATIVO"); } else { System.out.println("EL NUMERO INGRESADO ES POSITIVO"); }
}}
10.-Introducir un numero por teclado. Que nos diga si es par o impar.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package paridad;
import java.io.*;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { int num = 0; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese el primer numero"); String tex = obj.readLine(); num = Integer.parseInt(tex);
if ((num % 2) == 0) { System.out.println("el numero es par"); } else { System.out.println("el numero es impar"); }
}}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
11.-Imprimir y contar los multiplos de 3 desde la unidad hasta un número que
Introducimos por teclado.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package multiplo_3;import java.io.*;/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { int i=3,numero=0,contador=0; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese el primer numero"); String tex = obj.readLine(); numero = Integer.parseInt(tex);
while (i <= numero) { if ((i % 3) == 0) { System.out.println(i); contador = contador + 1; } i = i + 1; } System.out.println("hay: " + contador+ " numeros multiplos" ); }
}12.-Hacer un pseudocodigo que imprima los números del 1 al 100. Que calcule la suma de todos los números pares por un lado, y por otro, la de todos los impares.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package suma_par_impar;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) { int i = 1, sumapares = 0, sumaimpares = 0; while (i <= 100) { System.out.println(i); if ((i % 2) == 0) { sumapares = sumapares + i; } else { sumaimpares = sumaimpares + i; } i=i+1; } System.out.println("La suma de los numeros pares es: "+sumapares); System.out.println("La suma de los numeros impares es: "+sumaimpares); }}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
13.-Imprimir y contar los numeros que son multiplos de 2 o de 3 que hay entre 1 y 100.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package multiplos_2_3;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) { int i = 1, contador = 0;
while (i <= 100) { if ((i % 2 == 0) | (i % 3 == 0)) { contador = contador + 1; System.out.println(i); } i = i + 1; } System.out.println("El numero de multiplos es: " + contador); }}
14.-Hacer un pseudocodigo que imprima el mayor y el menor de una serie de cinco números que vamos introduciendo por teclado.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package mayor_menor;
import java.io.*;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { int contador = 0, numero = 0, nummaximo = 0, numminimo = 1000000;
while (contador < 5) { BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese el primer numero"); String tex = obj.readLine(); numero = Integer.parseInt(tex);
if (numero > nummaximo) { nummaximo = numero; } if (numero < numminimo) { numminimo = numero; } contador = contador + 1; } System.out.println("El numero mayor es: " + nummaximo); System.out.println("El numero mayor es: " + numminimo); }}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
15.-Introducir dos números por teclado. Imprimir los números naturales que hay entre ambos números empezando por el m s pequeño, contar cuantos hay y cuántos de ellos son pares. Calcular la suma de los impares.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package ejemplo_15;import java.io.*;
/** * * @author Mrangel */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { // TODO code application logic here int numero1 = 0, numero2 = 0, auxiliar = 0, contador = 0, pares =0, sumaimpares = 0; InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); System.out.println("digite el primer numero"); String texto=br.readLine(); numero1=Integer.parseInt(texto); System.out.println("digite el segundo numero"); String texto1=br.readLine(); numero2=Integer.parseInt(texto1);
if (numero1>numero2){ auxiliar = numero1;
numero1 = numero2;numero2 = auxiliar;
} while(numero1 <= numero2){ System.out.println(numero1); contador += 1; if (numero1%2==0){ pares +=1; }else{ sumaimpares =sumaimpares+numero1; } numero1 +=1; } System.out.println("hay " + contador + " numeros de intervalos"); System.out.println("hay " + pares + " numeros pares");
System.out.println("La suma de los numeros impares es: " + sumaimpares);
}}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
16.-Imprimir diez veces la serie de números del 1 al 10.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package repeticion_1_a_10;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) { int repeticion = 0, numero = 1; while (repeticion < 10) { while (numero <= 10) { System.out.print(numero); numero = numero + 1; } repeticion = repeticion + 1; } }}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
17.-Imprimir, contar y sumar los múltiplos de 2 que hay entre una serie de números, tal que el segundo sea mayor o igual que el primero.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package ejemplo_17;import java.io.*;/** * * @author Mrangel */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException {
int contador = 0;int suma =0;int numero1 = 0;int numero2 =999;
InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); System.out.println("digite el numero"); String texto=br.readLine(); numero1=Integer.parseInt(texto); System.out.println("Digite un numero mayor o igual que el anterior"); String texto1=br.readLine(); numero2=Integer.parseInt(texto1);
if (numero1%2 == 0){ // System.out.println(numero1); contador += 1;
suma += numero1;
numero1 += 1; } else{ System.out.println(" el numero debe ser mayor que el primer"); } System.out.println("Numeros de multiplos de 2 es: " + contador);
System.out.println ("La suma de los multiplos de 2 es: " + suma);}
}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
19.-Hacer un pseudocodigo que simule el funcionamiento de un reloj digital y que permita ponerlo en hora.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package reloj;
/** * * @author Mrangel */import java.io.*;public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { int horas = 0;
int minutos = 0;int segundos = 0; InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr); System.out.println("digite la hora"); String texto=br.readLine(); horas=Integer.parseInt(texto); System.out.println("digite los minutos"); String texto1=br.readLine(); minutos=Integer.parseInt(texto1);
System.out.println("digite los segundos"); String texto2=br.readLine(); segundos=Integer.parseInt(texto2);
while (horas < 24 ){while( minutos < 60 ){
while (segundos < 60 ){ System.out.println(" "+ horas + ": " + minutos + ":" + segundos); segundos += 1; }
minutos += 1;segundos = 0;
}horas += 1;minutos = 0;
}horas = 0;
}}
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package factorial;import java.io.*;/** * * @author Adrian Gonzalez */public class Main {
public static void main(String[] args) throws IOException { int factorial = 1,numero=0; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese el primer numero"); String tex = obj.readLine(); numero = Integer.parseInt(tex);
if (numero < 0){ System.out.println("no tiene factorial"); } else{ while (numero > 1){ factorial=factorial*numero; numero=numero-1; } } System.out.println("el factorial: "+factorial); }
}
21.-Hacer un programa que calcule independientemente la suma de los pares y los impares de los números entre 1 y 1000, utilizando un switch.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
* * @author Mrangel */public class Main { public static void main(String[] args) { // TODO code application logic here int par = 0; int impar =0; int sw = 0; int i = 1; while (i<=1000){ if (sw==0){ impar += i; sw = 1; }else{ par += i; sw = 0; } i += 1; } System.out.println("La suma de los pares es: "); System.out.println(par);System.out.println("La suma de los impares es: "); System.out.println(impar);
}
}
24.-Comprobar si un número mayor o igual que la unidad es primo.
package primos;import java.io.*;
Versión 2.0 del documento Actualizado el 1 de marzo 2011
/** * @author Adrian Gonzalez */public class Main { public static void main(String[] args) throws IOException { int contador = 0, numero = 0; while (contador <= 10) { BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Ingrese el primer numero"); String tex = obj.readLine(); numero = Integer.parseInt(tex); int divisores = 2; if (numero > 3) { int i = 2; while (i == numero) { if (numero != i & numero % i == 0) { divisores = divisores + 1; } i = i + 1; } } if (divisores <= 2) { System.out.println(numero + " es primo"); } else { System.out.println(numero + " no es primo y tiene " + divisores + " divisores entre 1 y " + numero); } contador = contador + 1; } }}
25.-Introducir un número menor de 5000 y pasarlo a numero romano.Proceso sin_tituloEscribir "digite el numero";
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Leer num; MIENTRAS num < 1 O num > 5000 HACER ESCRIBIR "N£mero: " ESCRIBIR num FINMIENTRAS col <- 15 MIENTRAS num >= 1000 HACER ESCRIBIR "M" num <- num - 1000 col <- col + 1 FINMIENTRAS SI num >= 900 ENTONCES ESCRIBIR "CM" num <- num - 900 col <- col + 2 FINSI SI num >= 500 ENTONCES ESCRIBIR "D" num <- num - 500 col <- col + 1 FINSI MIENTRAS num >= 100 HACER ESCRIBIR "C" num <- num - 100 col <- col + 1 FINMIENTRAS SI num >= 90 ENTONCES ESCRIBIR "XC" num <- num - 90 col <- col + 2 FINSI SI num >= 50 ENTONCES ESCRIBIR "L" num <- num - 50 col <- col + 1 FINSI SI num >= 40 ENTONCES ESCRIBIR "XL" num <- num - 40 col <- col + 2 FINSI MIENTRAS num >= 10 HACER
ESCRIBIR "X"
num <- num - 10
col <- col + 1
FINMIENTRAS
Versión 2.0 del documento Actualizado el 1 de marzo 2011
SI num = 9 ENTONCES
ESCRIBIR "IX"
num <- num - 9
col <- col + 2
FINSI
SI num >= 5 ENTONCES
ESCRIBIR "V"
num <- num - 5
col <- col + 1
FINSI
SI num >= 4 ENTONCES
ESCRIBIR "IV"
num <- num - 4
col <- col + 2
FINSI
MIENTRAS num > 0 HACER
ESCRIBIR "I"
num <- num - 1
col <- col + 1
FINMIENTRAS
FinProceso
package numeros_romanos;import java.io.*;
Versión 2.0 del documento Actualizado el 1 de marzo 2011
/** * * @author Mrangel */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) throws IOException { // TODO code application logic here InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); System.out.println("digite el numero"); String texto=br.readLine(); int num=Integer.parseInt(texto);
while( num < 1 | num > 5000) { // System.out.println(" numero"); System.out.println(num);
}
while( num >= 1000){
System.out.println("M" );
num -= 1000;
}
if( num >= 900){
System.out.println("CM");
num -= 900;
}
if (num >= 500){ System.out.println("D");
num -= 500; }
while( num >= 100){
System.out.println("C");
Versión 2.0 del documento Actualizado el 1 de marzo 2011
num -= 100; }
if (num >= 90){ System.out.println("XC"); }
num -= 90;
if (num >= 50){ System.out.println("L"); num -= 50; }
if (num >= 40){System.out.println("XL");
num -= 40;
}
while (num >= 10){ System.out.println("X");
num -= 10; }
if( num == 9){ System.out.println("IX"); num -= 9; } if (num >= 5){ System.out.println("V"); num -= 5; }
if (num >= 4){ System.out.println("IV"); num -= 4; }
while (num >= 0){ System.out.println("I"); num -= 1; } }
}
26.- hacer un ejemplo que utilice vectores.
Versión 2.0 del documento Actualizado el 1 de marzo 2011
package vectores;
/** * * @author Adrian Gonzalez */public class Main {
/** * @param args the command line arguments */ public static void main(String[] args) {
int matriz[][] = new int[3][];matriz[0] = new int[2];matriz[1] = new int[3];matriz[2] = new int[4];
// Ponemos datos en el arrayfor ( int i=0; i < 3; i++ ) {for ( int j=0; j < matriz[i].length; j++ )matriz[i][j] = i * j;}
// y vemos su contenido, utilizando un bucle forfor ( int i=0; i < 3; i++ ) {for ( int j=0; j < matriz[i].length; j++ )System.out.print( matriz[i][j] );System.out.println();}
// Intetamos acceder a un elemento que esta fuera de los limites del arraySystem.out.println( "Elemento fuera de limites del array" );matriz[4][0] = 7;// El compilador lanzara una excepción de tipo ArrayIndexOutOfBounds}}
CONCLUSIONES
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Se puede concluir las importancia que tienes los algoritmos para la solución de problemas, ya que por medio de este se puede diseñar un procedimiento que llevara pasos lógicos para darle la respuesta más cercana y optima a un problema dado.
Se concluye, que un problema dado tienes distintas soluciones y que por medio del análisis de algoritmos podemos saber cuál de todas esas posibles soluciones sería la más adecuada y cuál de ellas satisface todos los requerimientos del problema.
Las matrices y vectores nos ayudan a almacenar grandes cantidades de información, y nos permiten encontrar cualquier elemento almacenado, de forma más sencilla.
REFERENCIAS
Versión 2.0 del documento Actualizado el 1 de marzo 2011
Consultado el 05 de febrero de 2011 en la página web: http://es.wikipedia.org/wiki/Algoritmo#An.C3.A1lisis_de_algoritmos
Consultado el 05 de febrero de 2011 en la página web : www.oocities.com/info.../analisis_de_algoritmo/Notacion_o_grande.doc
Consultado el 05 de febrero de 2011 en la página web: http://www.isa.cie.uva.es/~maria/tema3.pdf
Consultado el 06 de febrero de 2011 en la página web:http://www.monografias.com/trabajos11/alcom/alcom.shtml#mar
Consultado el 04 de febrero de 2011 en la página web:http://colabora.inacap.cl/sedes/ssur/Asignatura%20Indtroduccion%20a%20la%20Programacn/An%C3%A1lisis%20de%20Algoritmo/Manual-Analisis%20de%20Algoritmos_v1.pdf
Consultado el 26 de febrero de 2011 en la página web:http://elvex.ugr.es/decsai/java/pdf/6A-Arrays.pdf
Consultado el 27 de febrero de 2011 en la página web:http://serdis.dis.ulpgc.es/~itop-ib/Algoritmica/tema4-ll.doc
Consultado el 01 de marzo de 2011 en la página web:http://www.magusoft.net/compuv/01_Netbeans.html