Manual de Java

Algoritmia
CAPITULO I
METODOLOGIA DE LA PROGRAMACION
1.1. INTRODUCCIÓN Y MOTIVACIÓN

Este capitulo le introduce al estudiante a seguir una metodología para la
resolución de problemas con computadoras y el uso del lenguaje de
programación Java.
La resolución de un problema con una computadora se hace escribiendo
un programa, que exige al menos los siguientes pasos: Definición o
análisis del problema, diseño del algoritmo, transformación del algoritmo
en un programa y ejecución y validación del programa.
Uno de los objetivos fundamentales de este manual es el aprendizaje y
diseño de los algoritmos. Este capitulo introduce al lector en el concepto
de algoritmo y de programa, así como las herramientas que permiten
“dialogar” al usuario con la maquina: los lenguajes de programación.
1.2. FASES EN LA RESOLUCIÓN DE PROBLEMAS

El proceso de resolución de un problema con una computadora conduce
a la escritura de un programa y a su ejecución en la misma. Aunque el
proceso de diseñar programa es esencialmente un proceso creativo, se
______________________________________________________ 5
Algoritmia
puede considerar una serie de fases o pasos comunes, que generalmente
deben seguir todos los programadores.
Las fases de resolución de un problema con computadora son:
 Análisis del problema

 Diseño del algoritmo
 Codificación
 Compilación y ejecución
 Verificación
 Depuración
 Mantenimiento
 Documentación
Constituye el ciclo de vida del software y sus características más

sobresalientes son:
 Análisis. El problema se analiza teniendo presente

la especificación de los requisitos dados por el cliente de la
empresa o por la persona que encarga el programa.
 Diseño. Una vez analizado el problema, se diseña
una solución que conducirá a un algoritmo que resuelva el
problema.
 Codificación (implementación). La solución se
escribe en la sintaxis del lenguaje de alto nivel y se obtiene un
programa fuente que se compila a continuación.
 Ejecución, verificación y depuración. El
programa se ejecuta, se comprueba rigurosamente y se
eliminan todos los errores (denominados “Bugs”, en inglés) que
puedan aparecer.
 Mantenimiento. El programa se actualiza y
modifica, cada vez que sea necesario, de modo que se cumplan
todas las necesidades de cambio de sus usuarios.
 Documentación. Escritura de las diferentes fases
del ciclo de vida del software, esencialmente el análisis, diseño
y codificación, unidos a manuales de usuario y de referencia, así
como normas para el mantenimiento.
Las dos primeras fases conducen a un diseño detallado escrito en
forma de algoritmo. Durante la tercera etapa (codificación) se
implementa el algoritmo en un código escrito en un lenguaje de
______________________________________________________ 6
Algoritmia
programación, reflejando las ideas desarrolladas en las fases de análisis y
diseño.
Las fases de compilación y ejecución traducen y ejecutan el
programa. En las fases de verificación y depuración el programador
busca errores de las etapas anteriores y los elimina. Comprobara que
mientras más tiempo se gaste en la fase de análisis y diseño, menos se
gastará en la depuración del programa. Por último, se debe realizar la
documentación del programa.
Antes de conocer las tareas a realizar en cada fase, vamos a
considerar el concepto y significado de la palabra algoritmo. La palabra
algoritmo se deriva de la traducción al latín de la palabra Alkho-
warizmi, nombre de un matemático y astrónomo árabe que escribió un
tratado sobre la manipulación de números y ecuaciones en el siglo IX.
Un algoritmo es un método para resolver un problema mediante una
serie de pasos precisos, definidos y finitos.
Características de un algoritmo
 Preciso (indica el orden de realización en cada paso),

 Definido (si se sigue dos veces, obtiene el mismo resultado
cada vez),
 Finito (tiene fin; un número determinado de pasos).
Un algoritmo debe producir un resultado en un tiempo finito. Los

métodos que utilizan algoritmos se denominan métodos algorítmicos, en
oposición a los métodos que implican algún juicio o interpretación que
se denominan métodos heurísticos. Los métodos algorítmicos se pueden
implementar en computadoras; sin embargo, los procesos heurísticos no
han sido convertidos fácilmente en las computadoras. En los últimos
años las técnicas de inteligencia artificial han hecho posible la
implementación del proceso heurístico en computadoras.
Ejemplos de algoritmos son: instrucciones para obtener el máximo
común divisor de dos números, calculo del factorial de un numero,
calculo de la tabal de multiplicar del 1 al 12, etc. Los algoritmos se
pueden expresar por fórmulas, diagramas de flujo o N-S y
pseudocódigos.
______________________________________________________ 7
Algoritmia
1.2.1. Análisis del Problema

La primera fase de la resolución de un problema con computadora
es el análisis del problema. Esta fase requiere una clara
definición, donde se contemple exactamente lo que debe hacer el
programa y el resultado o solución deseada.
Dado que se busca una solución por computadora, se precisan
especificaciones detalladas de entrada y salida. La Figura 1
muestra los requisitos que se deben definir en el análisis.
Resolución
de un problema
Análisis Diseño Resolución del

del del problema con
problema algoritmo computadora
Figura 1. Análisis del problema
Para poder identificar y definir bien un problema es conveniente

responder a las siguientes preguntas:
 ¿Qué entradas se requieren? (tipo de datos con los cuales
se trabaja y cantidad).
 ¿Cuál es la salida deseada? (tipo de datos de los
resultados y cantidad).
 ¿Qué método produce la salida deseada?
 Requisitos o requerimientos adicionales y restricciones a
la solución.
Ejemplo:
Se desea obtener una tabla con las depreciaciones acumuladas y
los valores reales de cada año, de un automovil comprado en
______________________________________________________ 8
Algoritmia
1,800.00 soles en el año 1985, durante los seis años siguientes
suponiendo un valor de recuperación o rescate de 120.00. Realizar
el análisis del problema, conociendo la fórmula de la depreciación
anula constante D para cada año de vida útil.
D= Costo – valor de recuperación

Vida útil
D = 1.800.00 – 120.00 = 1,680.00 = 280.00

6 6
Costo original
Entrada Vida útil
Valor de recuperación
Depreciación acumulada
Proceso cálculo de la depreciación acumulada cada año

Cálculo del valor del automovil en cada año
Depreciación anual
SalidaDepreciación acumulada en cada año
Valor del automovil en cada año
1.2.2. Diseño del Algoritmo
En la etapa de análisis del proceso de programación se determina

qué hace el programa. En la etapa de diseño se determina cómo
hace el programa la tarea solicitada. Los métodos más eficaces
para el proceso de diseño se basan en el conocido divide y
vencerás. Es decir, la resolución de un problema complejo se
realiza dividiendo el problema en subproblemas y a continuación
dividiendo estos subproblemas en otros de nivel más bajo, hasta
que pueda ser implementada una solución en la computadora. Este
método se conoce técnicamente como diseño descendente (top-
down) o modular. El proceso de romper el problema en cada
etapa y expresar cada paso en forma más detallada se denomina
refinamiento sucesivo.
______________________________________________________ 9
Algoritmia
Cada subprograma es resuelto mediante un módulo
(subprograma) que tiene un sólo punto de entrada y un sólo punto
de salida.
Cualquier programa bien diseñado consta de un programa
principal (el módulo de nivel más alto) que llama a subprogramas
(módulos de nivel más bajo) que a su vez pueden llamar a otros
subprogramas. Los programas estructurados de esta forma se dice
que tienen un diseño modular y el método de romper el programa
en módulos mas pequeños se llama programación modular. Los
módulos pueden ser planeados, codificados, comprobados y
depurados independientemente (incluso por diferentes
programadores) y a continuación combinarlos entre sí. El proceso
implica la ejecución de los siguientes pasos hasta que el programa
se termina:
1. Programar un módulo.
2. Comprobar el módulo.
3. Si es necesario, depurar el modulo.
4. Combinar el módulo con los módulos anteriores.
1.2.3. Herramientas de Programación
Las dos herramientas más utilizadas comúnmente para diseñar

algoritmos son: diagramas de flujo y pseudocódigos.
Un diagrama de flujo (flowchart) es una representación
gráfica de un algoritmo. Los símbolos utilizados han sido
normalizados por el Instituto Norteamericano de Normalización
(ANSI), y los más frecuentemente empleados se muestran en la
Figura 2.
______________________________________________________ 10
Algoritmia
Entrad
Terminal Subprograma a/
Salida
Proceso
Si
Decisió
n No
Conectores
Si
Figura 2. Símbolos más utilizados en los diagramas de flujo
El pseudocódigo es una herramienta de programación en la que

las instrucciones se escriben en palabras similares al inglés o
español, que facilitan tanto la escritura como la lectura de
programas. En esencia, el pseudocódigo se puede definir como un
lenguaje de especificaciones de algoritmos.
Aunque no existen reglas para escritura del pseudocódigo
en español, se ha recogido una notación estándar que se utilizara
en el presente manual y que ya es muy empleada en los libros de
programación en español. Las palabras reservadas básicas se
representan en letras negritas minúsculas. Estas palabras son
traducción libre de palabras reservadas de lenguajes como C,
pascal, etc.
Ejemplo:
______________________________________________________ 11
Algoritmia
Algoritmo que permite calcular el mayor valor de dos números
ingresados por teclado, en el caso de ser iguales mostrara un
mensaje que no existe numero mayor, los números son iguales.
Inicio:
Leer n1, n2
Si n1 = n2 entonces
Imprimir No existe número mayor, los números son
iguales
Caso contario:
Si n1>n2 entonces
Imprimir El número mayor es n1
Caso contrario:
Imprimir El número mayor es n2
Fin de si
Fin de si
Fin
1.2.4. Herramientas de Programación

Codificación es la escritura en un lenguaje de programación de la
representación del algoritmo. Dado que el diseño de un algoritmo
es independiente del lenguaje de programación utilizado para su
implementación, el código puede ser escrito con igual facilidad en
un lenguaje o en otro.
Para realizar la conversión del algoritmo en programa se
deben de sustituir las palabras reservadas en español por sus
homónimos en inglés, y las operaciones/ instrucciones indicadas
en lenguaje natural expresarlas en el lenguaje de programación
correspondiente.
1.2.5. Compilación y Ejecución de un Programa
______________________________________________________ 12
Algoritmia
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 disco.
El programa fuente debe ser traducido a lenguaje de
maquina, este proceso se realiza con el compilador y el sistema
operativo que se encarga prácticamente de la compilación.
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 el programa objeto que todavía no
es ejecutable directamente. Suponiendo que no existen errores en
el programa fuente, se debe instruir al sistema operativo para que
realice la fase de montaje o enlace (link), carga, del programa
objeto con las bibliotecas del programa del compilador. El
proceso de montaje produce un programa ejecutable. La Figura 3
describe el proceso completo de compilación/ejecución de un
programa.
______________________________________________________ 13
Algoritmia
Figura 3. Fases de la compilación/ejecución de un programa:

a) edición; b) compilación; c) montaje o enlace
1.2.6. Verificación y Depuración de un Programa
La verificación o compilación de un programa es el proceso de

ejecución del programa con una amplia variedad de datos de
entrada, llamados datos de test o prueba, que determinarán si el
programa tiene errores. Para realizar la verificación se debe
desarrollar una amplia gama de datos de test: valores normales de
entrada, valores extremos de entrada que comprueben los limites
del programa y valores de entrada que comprueben aspectos
especiales del programa.
La depuración es el proceso de encontrar los errores del
programa y corregir o eliminar dichos errores.
______________________________________________________ 14
Algoritmia
Cuando se ejecuta un programa, se pueden producir tres
tipos de errores:
1. Errores de Compilación. Se producen normalmente
por un uso incorrecto de las reglas del lenguaje de
programación y suelen ser errores de sintaxis. Si existe
un error de sintaxis, la computadora no puede
comprender la instrucción, no se obtendrá el programa
objeto y el compilador imprimirá una lista de todos los
errores encontrados durante la compilación.
2. Errores de Ejecución. Estos errores se producen por
instrucciones que la computadora puede comprender
pero no ejecutar. Ejemplos típicos son: división por
cero y raíces cuadradas de números negativos. En estos
casos se detiene la ejecución del programa y se
imprime un mensaje de error.
3. Errores Lógicos. Se producen en la lógica del
programa y la fuente de error suele ser el diseño del
algoritmo. Estos errores son los más difíciles de
detectar, ya que el programa puede funcionar y no
producir errores de compilación ni de ejecución, y sólo
puede advertirse el error por la obtención de resultados
incorrectos. En este caso se debe volver a la fase de
diseño del algoritmo, modificar el algoritmo, cambiar
el programa fuente y compilar y ejecutar una vez más.
1.2.7. 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 dicho problema. La
importancia de la documentación debe ser destacada por su
decisiva influencia en el producto final. Programas pobremente
documentados son difíciles de leer, más difíciles de depurar y casi
imposible de mantener y modificar.
La documentación de un programa puede ser interna y
externa. La documentación interna es la contenida en líneas de
comentarios. La documentación externa incluye análisis,
diagramas de flujo y/o pseudocódigos, manuales de usuario con
instrucciones para ejecutar el programa y para interpretar los
resultados.
______________________________________________________ 15
Algoritmia
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.
1.3. PROGRAMACION MODULAR
La programación modular es uno de los métodos de diseño más flexible

y potente para mejorar la productividad de un programa. En
programación modular el programa se divide en módulos (partes
independientes), cada uno de las cuales ejecuta una única actividad o
tarea y se codifican independientemente de otros módulos. Cada uno de
estos módulos se analiza, codifica y pone a punto por separado. Cada
programa contiene un módulo denominado programa principal que
controla todo lo que sucede; se transfiere el control a submódulos
(subprogramas), de modo que ellos puedan ejecutar sus funciones; sin
embargo, cada submódulo devuelve el control al módulo principal
cuando se haya completado su tarea. Si la tarea asignada a cada
submódulo es demasiado compleja, éste deberá romperse en otros
módulos más pequeños. El proceso sucesivo de subdivisión de módulos
continúa hasta que cada módulo tenga solamente una tarea especifica que
ejecutar. Esta tarea puede ser entrada, salida, manipulación de datos,
control de otros módulos o alguna combinación de éstos. Un módulo
puede transferir temporalmente el control a otro módulo; sin embargo,
cada módulo debe eventualmente devolver el control al módulo del cual
se recibe originalmente el control.
Los módulos son independientes en el sentido en que ningún
módulo puede tener acceso directo a cualquier otro módulo excepto el
módulo al que llama y sus propios submódulos. Sin embargo, los
resultados producidos por un módulo pueden ser utilizados por cualquier
otro módulo cuando se transfiera a ellos el control.
Raíz
Modulo 1 Modulo 2
______________________________________________________ 16
Modulo Modulo Modulo Modulo

11 12 21 22
Algoritmia
Figura 4. Programación Modular

Dado que los módulos son independientes, diferentes programadores
pueden trabajar simultáneamente en diferentes partes del mismo
programa. Esto reducirá el tiempo del diseño del algoritmo y posterior
codificación del programa. Además, un módulo se puede modificar
radicalmente sin afectar a otros módulos, incluso sin alterar su función
principal.
La descomposición de un programa en módulos independientes más
simples se conoce también como el método de “divide y vencerás”. Se
diseña cada módulo con independencia de los demás, y siguiendo un
método ascendente o descendente se llegará hasta la descomposición
final del problema en módulos en forma jerárquica.
1.4. PROGRAMACION ESTRUCTURADA
Los términos programación modular, programación descendente y

programación estructurada se introdujeron en la mitad de la década de
los sesenta y a menudo se utilizan como sinónimos aunque no significa
lo mismo. La programación estructurada significa escribir un programa
de acuerdo a las siguientes reglas:
 El programa tiene un diseño modular
 Los módulos son diseñados de modo descendente
 Cada módulo se codifica utilizando las tres estructuras de control
básicas: secuencia, selección y repetición.
El término programación estructurada se refiere a un conjunto de
técnicas que han ido evolucionando desde los primeros trabajos de Edgar
Dijkstra. Estas técnicas aumentan considerablemente la productividad
del programa reduciendo en elevado grado el tiempo requerido para
escribir, verificar, depurar y mantener los programas. La programación
estructurada utiliza un número limitado de estructuras de control que
______________________________________________________ 17
Algoritmia
minimizan la complejidad de los programas y, por consiguiente, reducen
los errores; hace los programas más fáciles de escribir, verificar, leer y
mantener. Los programas deben estar dotados de una estructura.
La programación estructurada es el conjunto es el conjunto de
técnicas que incorporan:
 Recursos abstractos,
 Diseño descendente (top-down),
 Estructuras básicas.
1.4.1. Recursos Abstractos
La programación estructurada se auxilia de los recursos abstractos

en lugar de los recursos concretos de que dispone un determinado
lenguaje de programación.
Descomponer un programa en términos de recursos
abstractos según Dijkstra, consiste en descomponer una
determinada acción compleja en términos de un número de
acciones más simples capaces de ejecutarlas o que constituyan
instrucciones de computadoras disponibles.
1.4.2. Diseño Descendente (top-down)
El diseño descendente (top-down) es el proceso mediante el cual

un problema se descompone en una serie de niveles o pasos
sucesivos de refinamiento. La metodología descendente consiste
en efectuar una relación entre las sucesivas etapas de
estructuración de modo que se relacionasen unas con otras
mediante entradas y salidas de información. Es decir, se
descompone el problema en etapas o estructuras jerárquicas, de
forma que se puede considerar cada estructura desde dos puntos
de vista: ¿qué hace? Y ¿cómo lo hace?
Si se considera un nivel “n” de refinamiento, las
estructuras se consideran de la siguiente manera:
______________________________________________________ 18
Algoritmia
Nivel n: desde el exterior Nivel n+1: Vista desde el interior

“¿qué hace? “¿cómo lo hace?
Figura 5. Diseño Descendente
1.4.3. Estructuras de Control

Las estructuras de control de un lenguaje de programación son
métodos de especificar el orden en que las instrucciones de un
algoritmo se ejecutarán. El orden de ejecución de las sentencias o
instrucciones determina el flujo de control. Estas estructuras de
control son, por consiguiente, fundamentales en los lenguajes de
programación y en los diseños de algoritmos, especialmente los
pseudocódigos.
Las tres estructuras de control básicos son:
______________________________________________________ 19
Algoritmia
 Secuencia,
 Selección,
 Repetición.
La programación estructurada hace los programas más
fáciles de escribir, verificar, leer y mantener; utiliza un
número limitado de estructuras de control que minimizan la
complejidad de los problemas.
1.4.4. Teorema de la Programación Estructurada: Estructuras

Básicas
En mayo de 1996, Bohm y Jacopini demostraron que un programa

propio puede ser escrito utilizando solamente tres tipos e
estructuras de control.
 Secuenciales,
 Selectivas,
 Repetitivas.
Un programa se define como propio si cumple las
siguientes características:
 Posee un solo punto de entrada y uno de salida o fin para
control del programa.
 Existen caminos desde la entrada hasta la salida que se
pueden seguir y que pasan por todas las partes del
programa.
 Todas las instrucciones son ejecutables y no existen lazos
o bucles infinitos (sin fin).
La programación estructurada significa que:
 El programa completo tiene un diseño modular.

 Los módulos se diseñan con metodología descendente
(puede hacerse también ascendente).
 Cada módulo se codifica utilizando las tres estructuras
de control básicas: secuenciales, selectivas y
repetitivas
 Estructuración y modularidad son conceptos
complementarios
______________________________________________________ 20
Algoritmia
1.5. CONCEPTO Y CARACTERISTICAS DE ALGORITMOS
El objetivo fundamental de este manual es enseñar a resolver problemas

mediante una computadora. El programador de computadora es antes
que nada una persona que resuelve problemas, por lo que para llegar a
ser un programador eficaz se necesita aprender a resolver problemas de
un modo riguroso y sistemático.
Problema Diseño del Programa de

Algoritmo Computadora
Figura 6. Resolución de un Programa

Los pasos para la resolución de un problema son:
1. Diseño del algoritmo, que describe la secuencia ordenada de
pasos sin ambigüedades que conducen a la solución de un
problema dado(análisis del problema y desarrollo del
algoritmo)
2. Expresar el algoritmo como un programa en un lenguaje de
programación adecuado(Fase de codificación)
3. Ejecución y validación del programa por la computadora.
Para llegar a la realización de un programa es necesario el diseño

previo de un algoritmo, de modo que sin algoritmo no puede existir un
programa.
Los algoritmos son independientes tanto del lenguaje de
programación en que se expresan como de la computadora que los
ejecuta. En cada problema el algoritmo se puede expresar en un lenguaje
diferente de programación y ejecutarse en una computadora distinta; sin
embargo, el algoritmo será siempre el mismo.
En la ciencia de la computación y en la programación, los
algoritmos son más importantes que los lenguajes de programación o las
computadoras. Un lenguaje de programación es tan sólo un medio para
expresar un algoritmo y una computadora es sólo un procesador para
ejecutarlo. Por tanto el lenguaje de programación como la computadora
son los medios para obtener un fin: conseguir que el algoritmo se ejecute
y se efectúe el proceso correspondiente.
______________________________________________________ 21
Algoritmia
El diseño de la mayoría de los algoritmos requiere creatividad y
conocimientos profundos de la técnica de la programación. En esencia,
la solución de un problema se puede expresar mediante un algoritmo.
1.5.1. Características de los Algoritmos
Las características fundamentales que debe cumplir todo

algoritmo son:
 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. Si se sigue un algoritmo,
se debe terminar en algún momento; o sea, debe tener
un número finito de pasos.
Precisión
Definitud o determinismo
Finitud
Dada una cantidad de datos de entrada de un algoritmo, se dice

que la cantidad de un recurso usada por dicho algoritmo para su
ejecución determina la complejidad del algoritmo respecto a tal
recurso. Cuando se implementa un algoritmo en un computador
digital, los recursos con los que se cuenta son tiempo de proceso y
memoria. Por lo tanto, a un algoritmo implementado en un
computador digital se le pueden calcular sus complejidades
temporal y espacial
La definición de un algoritmo debe describir tres partes: Entrada,
proceso, y Salida.
1.5.2. Diseño del Algoritmo
Una computadora no tiene capacidad para solucionar problemas

más que cuando se le proporciona los sucesivos pasos a realizar.
Estos pasos sucesivos que indican las instrucciones a ejecutar por
la máquina constituyen, como ya conocemos, el algoritmo.
La información que se proporciona al algoritmo constituye
la entrada y la información producida por el algoritmo constituye
______________________________________________________ 22
Algoritmia
su salida. Los problemas complejos se pueden resolver más
eficazmente con la computadora cuando se rompen en
subproblemas que sean más fáciles de solucionar que el original.
Así el problema de encontrar la superficie y la longitud de un
círculo se puede dividir en tres problemas más simples o
subproblemas (Figura 7)
Superficie y
longitud de
circunferencia
Entrada de Cálculo de Cálculo de Salida de

datos superficie longitud Resultados
(S) (L)
Entrada
Radio (R) S = PI * R2 L = 2 * PI *
R
Salida Salida Salida

(R) (S) (L)
Figura 7. Refinamiento de un Algoritmo
Tras los pasos anteriores (diseño descendente y refinamiento por

pasos) es preciso representar el algoritmo mediante una
______________________________________________________ 23
Algoritmia
determinada herramienta de programación: diagrama de flujo,
pseudocódigo o diagrama N – S.
Así pues, el diseño del algoritmo se descompone en las
fases recogidas en la Figura 8:
Diseño de un
algoritmo
Diseño Refinamiento Herramientas de

descendente Por casos programación (3)
(1) (2) -diagrama de flujo
-pseudocódigo
-diagrama N-S
Figura 8. Fases del Diseño de un Algoritmo
1.6. REPRESENTACIÓN GRÁFICA DE LOS ALGORITMOS
Para representar un algoritmo se debe utilizar algún método que permita

independizar dicho algoritmo del lenguaje de programación elegido. Ello
permitirá que un algoritmo pueda ser codificado indistintamente en
cualquier lenguaje. Para conseguir este objetivo se precisa que el
algoritmo sea representado gráfica o numéricamente, de modo que las
sucesivas acciones no dependan de la sintaxis de ningún lenguaje de
______________________________________________________ 24
Algoritmia
programación, sino que la descripción pueda servir fácilmente para su
transformación en un programa, es decir, su codificación.
Los métodos usuales para representar un algoritmo son:
1. Lenguaje de especificación de algoritmos: pseudocódigo

2. Diagrama de flujo ó Diagrama N-S (Nassi – Schneiderman)
Cuando se plantean problemas basados en algoritmos, se debe tener
encuenta que:
Los problemas se clasifican por la existencia de una solución en

solubles, no solubles e indecidible.
 Un problema se dice SOLUBLE si se sabe de antemano que existe
una solución para él.
 Un problema se dice INSOLUBLE si se sabe que no existe una
solución para él.
 Un problema se dice INDECIDIBLE si no se sabe si existe o no
existe solución para él.
A su vez, los problemas solubles se dividen en dos clases: los

algorítmicos y los no algorítmicos.
 Un problema se dice ALGORÍTMICO si existe un algoritmo que

permita darle solución.
 Un problema se dice NO ALGORÍTMICO si no existe un
algoritmo que permita encontrar su solución.
1.6.1. Pseudocódigo
El pseudocódigo es un lenguaje de especificación de algoritmos.

El uso de tal lenguaje hace el paso de codificación final
relativamente fácil.
El pseudocódigo nació como un lenguaje similar al inglés y era un
medio de representar básicamente las estructuras de control de
programación estructurada. Se considera un primer borrador, dado
que el pseudocódigo tiene que traducirse posteriormente a un
lenguaje de programación. El pseudocódigo no puede ser
ejecutado por una computadora. La ventaja del pseudocódigo es
que en su uso, en la planificación de un programa, el programador
se puede concentrar en la lógica y en las estructuras de control y
no preocuparse de las reglas de un lenguaje específico. Es también
______________________________________________________ 25
Algoritmia
fácil modificar el pseudocódigo si se descubren errores o
anomalías en la lógica del programa, mientras que en muchas
ocasiones suele ser difícil el cambio en la lógica, una vez que está
codificado en un lenguaje de programación. Otra ventaja del
pseudocódigo es que puede ser traducido fácilmente a lenguajes
estructurados como C, C++, Java, C#, etc.
El algoritmo comienza con la palabra start y finaliza con la
palabra end, en inglés (en español, inicio, fin). Entre estas
palabras, sólo escribe una instrucción o acción por línea.
La línea precedida por // se denomina comentario. Es una
información al lector del programa y no realiza ninguna
instrucción ejecutable, sólo tiene efecto de documentación interna
del programa.
Por fortuna, aunque el pseudocódigo nació como un
sustituto del lenguaje de programación y, por consiguiente, sus
palabras reservadas se conservaron o fueron muy similares a las
del idioma inglés, el uso del pseudocódigo se ha extendido en la
comunidad hispana con términos en español como inicio, fin,
parada, leer, escribir, si – entonces, si – no, mientras, fin _
mientras, repetir, hasta _ qué, etc.
Secuencial
Inicio
acción1
acción2
acción n
Fin
Decisión Simple
______________________________________________________ 26
Algoritmia
si condición entonces
acción1
acción2
acción n
Decisión Doble
si condición entonces
acción1
acción2
en caso contrario
acción1
para var. Entera inicial hasta final hacer
acción2
acción1
acción2
Iteración Fija
.
.
______________________________________________________ 27
.
acción n
Algoritmia
Condicional al Inicio
mientras condición hacer
acción1
acción2
acción n
repita
acción1
acción2
Condicional
. al Final
.
______________________________________________________ 28
acción n
Hasta que condición

Algoritmia
Selección
casos selector de
valor 1 : acción1
acción2
valor 2 : acción1
acción2
...
valor n : acción1
acción2
______________________________________________________ 29
Algoritmia
Ejemplos de Algoritmos:
1. Un estudiante se encuentra en su casa (durmiendo) y debe ir a la

universidad
Inicio (a tomar la clase de algoritmia!), ¿qué debe hacer el
estudiante?
Dormir
ALGORITMO:
haga 1 hasta que suene el despertador (o lo llame la mamá).
Mirar la hora.
¿Hay tiempo suficiente?
Si hay, entonces
Bañarse.
Vestirse.
Desayunar.
Sino,
Vestirse.
Cepillarse los dientes.
Despedirse de la mamá y el papá.
¿Hay tiempo suficiente?
Si, Caminar al paradero.
Sino, Correr al paradero.
Hasta que pase un bus para la universidad haga:
Esperar el bus
Ver a las demás personas que esperan un bus.
Tomar el bus.
Mientras no llegue a la universidad haga:
Seguir en el bus.
______________________________________________________ 30
Pelear mentalmente con el conductor.
Timbrar.
Bajarse.
Entrar a la universidad.
Fin
Algoritmia
2. Cambiar la rueda pinchada de un automóvil teniendo un gato

mecánico en buen estado, una rueda de reemplazo y una llave inglesa.
ALGORITMO:
Inicio
PASO 1. Aflojar los tornillos de la rueda pinchada con la llave
inglesa.
PASO 2. Ubicar el gato mecánico en su sitio.
PASO 3. Levantar el gato hasta que la rueda pinchada pueda girar
libremente.
PASO 4. Quitar los tornillos y la rueda pinchada.
PASO 5. Poner rueda de repuesto y los tornillos.
PASO 6. Bajar el gato hasta que se pueda liberar.
PASO 7. Sacar el gato de su sitio.
PASO 8. Apretar los tornillos con la llave inglesa.
Fin
Inicio
PASO 1. Colocar los números el primero encima del segundo, de tal
manera que las unidades, decenas, centenas, etc., de los números que
den alineadas. Trazar una línea debajo del segundo número.
3. Realizar la suma de los números 2448 y 5746.
PASO 2. Empezar por la columna más a la derecha.
ALGORITMO:
PASO 3. Sumar los dígitos de dicha columna.
PASO 4. Si la suma es mayor a 9 anotar un 1 encima de la siguiente
columna a la izquierda y anotar debajo de la línea las unidades de la
______________________________________________________
suma. Si no es mayor anotar la suma debajo de la línea. 31
PASO 5. Si hay más columnas a la izquierda, pasar a la siguiente
columna a la izquierda y volver a 3.
PASO 6. El número debajo de la línea es la solución.
Fin
Algoritmia
4. Sean los puntos P=(a,b) y Q=(c,d) que definen una recta, encontrar un
segmento de recta perpendicular a la anterior que pasa por el punto
medio de los puntos dados.
ALGORITMO:
Inicio
PASO 1. Trazar un círculo con centro en el punto P que pase por el

punto Q.
______________________________________________________ 32
PASO 2. Trazar un círculo con centro en el punto Q que pase por el
punto P.
Algoritmia
PASO 3. Trazar un segmento de recta entre los puntos de

intersección de las circunferencias trazadas.
Fin. El segmento de recta trazada es el buscado.
______________________________________________________ 33
Algoritmia
5. Escribir un algoritmo que lea las cuatro notas de un estudiante e

imprima la nota definitiva.
ALGORITMO:
1. Inicio
2. leer n1, n2, n3, n4
3. suma = n1 + n2 + n3 + n4
4. parcial = suma*4/100
5. notadef = parcial + 1
6. Imprimir notadef
7. fin
6. Escribir un algoritmo que calcule e imprima el area de un triangulo:

ALGORITMO:
Inicio
leer datos: base, altura
Calcular area: area = (base*altura)/2
Imprimir base, altura, area
fin
7. Un vendedor recibe una comisión del 10% del total de ventas del mes.
El quiere saber cuanto ganará en un mes que tuvo tres ventas:
ALGORITMO:
______________________________________________________ 34
Algoritmia
Inicio
leer sueldobase, venta1, venta2, venta3
subtotal = venta1 + venta2 + venta3
comision = subtotal *0,10
total = sueldobase + comision
imprimir total
fin
8. Una tienda ofrece un 15% de descuento por cada compra. Un cliente

desea saber cuanto deberá pagar por su compra:
ALGORITMO:
Inicio
leer monto
descuento = monto * 0,15
total = monto - descuento
imprimir total
Fin
9. Hacer un algoritmo que lea los nombres y edades de dos personas e

imprima cual de ellas
tiene más edad.
ALGORITMO:
1. Inicio
2. leer nombre1 y edad1
3. leer nombre2 y edad2
4. comparar edad1 con edad2:
5. Si edad1 > edad2 imprimir nombre1, ” es mayor”
6. si edad2 > edad1 imprimir nombre2, ” es mayor”
7. Si edad1 = edad2 imprimir
8. Fin
______________________________________________________ 35
Algoritmia
10. En una Granja existen N conejos, N1 blancos y N2 negros. Se
venden X negros y Y blancos.
Hacer un algoritmo que:
a) Imprima la cantidad de conejos vendida
b) Si P1 es el precio de venta de los conejos blancos y P2 es el precio de
venta de los conejos negros, imprima el monto total de la venta.
c) Imprima el color de los conejos que se vendieron más.
ALGORITMO:
1. Inicio
2. Leer datos: N, N1,N2,X,Y,P1,P2
3. Calcular la cantidad de conejos vendida: CNV = X + Y
4. Imprimir la cantidad de conejos vendida: Imprimir CNV
5. Calcular el monto de la venta: MV = X * P2 + Y * P1
6. Imprimir monto de la venta: Imprimir MV
7. Si X > Y entonces
Imprimir “Se vendieron mas conejos negros”
en otro caso
Imprimir “Se vendieron mas conejos blancos”
8. Fin
11. Elaborar un algoritmo que lea el importe bruto de una factura y

determine el importe neto según los siguientes criterios:
Importe bruto menor de 20.000 -> sin descuento
Importe bruto mayor de 20.000 -> 15% de descuento
ALGORITMO:
1. Inicio
2. Leer importeb
3. Calcular descuento:
Si importeb >= 20000 entonces
descuento =importeb * 0.15;
en otro caso
______________________________________________________
descuento = 0 36
finsi
4. fin
Algoritmia
Ejercicios Propuestos:
Para los siguientes problemas dar un algoritmo y si es posible una

ejecución del mismo.
1. Buscar en el directorio telefónico, el número de:

a. José González Pérez
b. Pedro Gómez Bernal.
c. Escribir un algoritmo que sirva para buscar a cualquier persona.
2. Solicitar en préstamo algún libro de una biblioteca.
3. haga una caja de cartón con tapa de:

a. 20 cm de largo, por 10 cm de ancho y 5 cm de alto.
b. 10 cm de largo, por 30 cm de ancho y 15 cm de alto.
c. Escribir un algoritmo que sirva para construir una caja de cartón con
tapa de cualquier tamaño.
4. Construir un avión de papel.
5. Calcular manualmente la división de cualquier par de números

naturales. El resultado también debe ser un número natural. Escribir un
algoritmo para calcular el residuo de la división.
6. Un juego muy famoso entre dos niños es el de adivina mi número,el

cual consiste en que cada niño trata de adivinar el número
pensado por el otro niño. Dicho número generalmente está
entre 1 y 100. Las reglas del juego son las siguientes:
______________________________________________________ 37
Algoritmia
a. Cada niño posee un turno en el que trata de averiguar el número del

otro.
b. En su turno el primer niño pregunta si un número que dice es el
pensado por el segundo.
c. Si el número que ha dicho el primer niño es el que pensó el segundo,
este último debe informarle al primero que ganó.
d. Si el número no es el segundo niño debe decir si su número pensado
es menor o mayor al que el primer niño dijo.
e. Luego el segundo niño tiene su turno y de esta manera se van
intercalando hasta que alguno de los dos gane.Desarrollar un algoritmo
para jugar adivina mi número.
7.Una balanza se encuentra en equilibrio cuando el producto

de la carga aplicada sobre el brazo derecho por la longitud
de este brazo, es igual al producto de la carga aplicada sobre
el brazo izquierdo por la longitud de este otro brazo.
Determinar si la balanza se encuentra en equilibrio si:
a. La longitud del brazo izquierdo es 3 m, la del derecho es 2 m, la carga
aplicada al brazo izquierdo es 5 Kg y la carga aplicada al derecho es 7
Kg.
b. La longitud del brazo izquierdo es 4 m, la del derecho es 2 m, la carga
aplicada al brazo izquierdo es 4 Kg y la carga aplicada al derecho es 4
Kg.
c. Desarrollar un algoritmo que sirva para cualquier conjunto de valores
para las longitudes de los brazos y las cargas aplicadas.
8. Si Juan tiene el doble de la edad de Pedro y la suma de las edades de

los dos es 33 años, ¿Cuántos años tiene Juan y cuántos tiene Pedro?.
9. Se tienen dos jarras (A y B) de capacidades 3 y 7 litros

respectivamente, sobre las cuales se pueden efectuar las siguientes
acciones: Llenar totalmente cualquiera de las dos jarras, vaciar una de las
dos jarras en la otra hasta que la jarra origen este vacía o hasta que la
jarra destino este llena y vaciar el contenido de una jarra (este llena o no)
en un sifón. ¿Cómo se puede dejar en la jarra A un solo litro utilizando
solamente las anteriores acciones?.
______________________________________________________ 38
Algoritmia
10. Tres personas deciden invertir su dinero para formar una empresa.
Cada una de ellas invierte una cantidad distinta. Hacer un algoritmo que
imprima el porcentaje que cada quien invierte con respecto al total de la
inversión
1.6.2. Diagrama de Flujo
Los diagramas de flujo son representaciones gráficas de

algoritmos. Un diagrama de flujo consta de símbolos, que
representan los pasos o etapas del algoritmo. Cada símbolo
representa un tipo de actividad.
Símbolos:
Los diferentes símbolos usados en un diagrama de flujo son:
______________________________________________________ 39
Algoritmia
Símbolo Paso ó Actividad
Entrada/Salida
Este símbolo representa una

entrada ó salida.
Proceso
Este símbolo representa

un proceso de una
entrada, tal como la suma
de dos números.
Decisión

una condición con la cual
se debe tomar una decisión.
______________________________________________________ 40
Algoritmia
Procedimiento/Subrutina

la llamada a un
procedimiento o
subrutina predefinido
compuesto de pasos que
no son parte de este
diagrama.
ó
Un programa grande puede
ser divido en subprogramas
pequeños llamados
procedimientos o subrutinas.
Este símbolo representa la
llamada a un procedimiento
o subrutina desde el
programa principal. El
procedimiento o subrutina es
completamente descrito en
un diagrama de flujo
diferente
Línea de flujo

los enlaces de un símbolo
con otro y ayuda a
entender la secuencia de
los pasos a seguir para
completar una tarea. Este
símbolo indica el flujo del
diagrama de flujo desde
arriba hacia abajo o de la
izquierda a la derecha.
______________________________________________________ 41
Algoritmia
Inicio y Fin
Este símbolo representa el
inicio y fin del diagrama de
flujo.
Conector en Página
Un diagrama de flujo se
puede dividir en partes
cuando muchas líneas del
flujo lo hacen ilegible. Este
símbolo representa la
conexión entre estas partes
del un diagrama de flujo en
una misma página. Este
símbolo es etiquetado con
letras en mayúsculas, por
ejemplo A.
Conector Fuera de Página

conexión entre las partes de
un diagrama de flujo en
páginas separadas. Esto
ayuda a prevenir confusión
respecto a la secuencia de un
diagrama de flujo cuando
este abarca múltiples
páginas. Este símbolo es
etiquetado con números, por
ejemplo 1.
______________________________________________________ 42
Algoritmia
Visualización

salida usando la instrucción
mostrar.
Ejemplos
El siguiente diagrama de flujo acepta dos números, calcula el

producto y muestra el resultado.
______________________________________________________ 43
Algoritmia
______________________________________________________ 44
Algoritmia
___________________________________________________
El siguiente diagrama de flujo acepta dos números, y muestra
el mayor de ellos después de compararlos.
______________________________________________________ 45
Algoritmia
___________________________________________________
El siguiente es el diagrama de flujo dado en el manual
de una televisión proporciona las recomendaciones para resolver
el problema de mal funcionamiento del control remoto.
______________________________________________________ 46
Algoritmia
___________________________________________________
Reglas de un Diagrama de Flujo
El American National Standards Institute (ANSI) recomienda un

número de reglas a cumplir en el dibujo de diagramas de flujo.
Algunas de estas reglas y pautas se muestran a continuación:
 La lógica completa de un diagrama de flujo debería

representarse usando los símbolos estándares.
 El diagrama de flujo debería ser claro, preciso y de fácil
interpretación.
 Los diagramas de flujo solo puede tener un punto de
inicio y un punto de término.
 Los pasos en un diagrama de flujo deberían seguir el
enfoque de arriba a abajo o de izquierda a derecha.
 Todas las entradas de datos necesarias deberían
exponerse en un orden lógico.
 Los símbolos de inicio y fin deberían tener una sola línea
de flujo.
 Los símbolos de entrada, procesamiento, salida y
visualización de datos deberían tener dos líneas de flujo
conectadas, una previa al símbolo y otra posterior al
símbolo.
 El símbolo de decisión debería tener una línea de flujo
conectada previo al símbolo y dos líneas de flujo conectadas
posterior al símbolo para cada posible solución.
Ventajas de los Diagramas de Flujo
Las ventajas de los diagramas de flujo son:
 Los diagramas de flujo es el mejor método de comunicar

lógica.
 Los diagramas de flujo ayudan a analizar los problemas
eficazmente.
 Los diagramas de flujo actúan como guía durante la
fase de diseño del programa.
 Es más fácil depurar errores de lógica usando un
diagrama de flujo.
 Los diagramas de flujo ayudan a mantener los
______________________________________________________ 47
Algoritmia
___________________________________________________
programas.
Desventajas de los Diagramas de Flujo
Las desventajas de los Diagramas de flujo son:
 Un diagrama de flujo largo puede extenderse sobre

múltiples páginas, lo cual reduce su legibilidad.
 Como los símbolos de los diagramas de flujo no pueden
escribirse, el dibujo de un diagrama de flujo usando
cualquier herramienta gráfica lleva mucho tiempo.
 Los cambios hechos en un solo paso pueden ocasionar
tener que volver a dibujar el diagrama de flujo completo.
 Un diagrama de flujo representando un algoritmo
complejo puede tener demasiadas líneas de flujo. Esto
reduce su legibilidad y llevará mucho tiempo dibujarlo y
entender su lógica.
______________________________________________________ 48
Algoritmia
___________________________________________________
CAPITULO II
VARIABLES, CONSTANTES, CONTADORES,

ACUMULADORES Y OPERADORES

Este capitulo le introduce al estudiante a conocer el uso de las variable,
constantes, contadores, acumuladores y expresiones utilizados
constantemente en la formulación de los diferentes algoritmos
propuestos. El estudiante entendera su uso de determinados problemas
planteados en clase y por si mismo, facilitando una mejor forma de dar
asolución a los algoritmos atravez de diagramas de flujo y codificación
en java.
2.2. INTRODUCCIÓN A LAS VARIABLES

La memoria interna del computador se utiliza para almacenar los datos
de entrada proporcionados por el usuario, las instrucciones para tratar
estos datos y el resultado del proceso o datos de salida. La memoria
consta de diversas localizaciones en las cuales se almacenan los datos.
Las variables pueden clasificarse en dos categorías:
______________________________________________________ 49
Algoritmia
___________________________________________________
Valores numéricos, como 25, 78 y 90.45. Esto quiere decir que los
valores numericos pueden clasificarse en enteros y reales
Valores de carácter como "Hola", "X", "E001" y "1988". Los

literales carácter siempre van entre comillas (" ")
Para entender como un computador procesa los datos, considere el

siguiente problema donde dos números son ingresados y el resultado se
muestra sobre la pantalla. El diagrama de flujo usado para representar la
lógica de la solución del problema es el siguiente:
______________________________________________________ 50
Algoritmia
___________________________________________________
Cuando las instrucciones son ejecutadas, el valor del primer número es
aceptado y almacenado en la memoria. De manera similar, el valor del
segundo número es también aceptado y almacenado en la memoria. El
computador hace referencia a los números almacenado en memoria,
calcula la suma, y almacena el resultado obtenido en una localización
diferente de la memoria. El computador hace referencia al
resultado almacenado en memoria, para mostrarlo en la pantalla.
Por lo tanto, el computador necesita identificar las localizaciones de
memoria para almacenar los valores o recuperar los valores
almacenados.
Las localizaciones cuando el primer número, el segundo número, y el
resultado son almacenados pueden ser referenciadas como nNumero1,
nNumero2 y nSuma respectivamente. Cada vez que el conjunto de
instrucciones son ejecutadas; los valores de nNumero1, nNumero2, y
nSuma variará, dependiendo de los valor ingresados por el usuario.
Por consiguiente, nNumero1, nNumero2, y nSuma son conocidos como
variables.
Tipos de Datos
El número de bytes que debe reservarse para las diferentes variables

depende del tipo de valor que éstas almacenan. Por lo tanto, hay una
necesidad de clasificar los tipos de datos que puedan ser almacén en la
______________________________________________________ 51
Algoritmia
___________________________________________________
memoria. Este tipo de valor es denominado tipo de dato. Los tipos de
datos están clasificados en:
 Numéricos: Las variables de tipo de dato numérico solo

pueden contener números. Por ejemplo; la edad de una persona, el
precio de un producto. Estas variables pueden almacenar números
de coma flotante y pueden ser usadas dentro de cálculos.
 Carácter: Las variables de tipo de dato carácter

pueden contener una combinación de letras, números, y
caracteres especiales. Por ejemplo; el nombre de una persona ó la
dirección postal. Estas variables no pueden ser usadas dentro de
cálculos.
Declaración de Variables
Es necesario declarar una variable antes de ser usada dentro de un

programa. Cuando se declara una variable, una posición de memoria
defina se esta asignado a la variable. La declaración de una variable
asigna un nombre a la variable y especifica el tipo de dato que la variable
puede almacenar.
Por ejemplo, se necesita desarrollar un pseudocódigo para aceptar el

nombre, edad, y teléfono de un cliente. Para aceptar el nombre, se
necesita declarar la variable de tipo carácter. De manera similar, es
necesario declarar dos variables numéricas con los nombres: edad y
telefono para aceptar la edad y teléfono del cliente. La declaración de
estas variables es como sigue:
char nombre
int edad, telefono
Aunque no hay convenciones para dar nombre a las variables, las

siguientes pautas pueden resultar útiles:
 La primera letra del nombre de la variable podría indicar el tipo

de dato de la variable. Por ejemplo, puede ser “c” o “n” para indicar
______________________________________________________ 52
Algoritmia
___________________________________________________
una variable carácter o numérica, respectivamente. Algunos
ejemplos son cNombre y nEdad.
 El nombre de la variable debería describir con claridad el

propósito de la variable. Por ejemplo, nNota es una variable
numérica para guardar la nota del alumno.
 El nombre de la variable no debería contener espacios o
símbolos tales como: !
 @ # $ % ^ & * ( ) { } [ ] . , : ; “ ‘ / y \. Se puede utilizar el
carácter de subrayado cuando sea necesario insertar un espacio en el
nombre de una variable, como por ejemplo, nSalario_Básico.
 Si el nombre de la variable está compuesto por varias
palabras sin espacios entre ellas, la primera letra de cada
palabra debería ir en mayúscula para facilitar la lectura.
2.3. CONSTANTES
Así como las variables la s contantes tambien se almacenan en la
memoria del computador al momento de ejecutarlas, con la diferencia
que las constantes son valores predefinidos en un programa que nuncan
cambian su valor y tambien pueden clasificarse en valores numericos
(enteros y reales) y valores de carácter. Por ejemplo:
Valores numéricos, como 34, 22 y 33.22. Esto quiere decir que los
valores numericos pueden clasificarse en enteros y reales
Valores de carácter como "Hola", "Jose", "E001" y "2009". Los

datos tipos carácter, siempre van entre comillas (" ")
2.4. CONTADORES
Los contadores son otro tipo de variables muy utilizados dentro de
estructuras repetitivas. Su función principal es contar una serie de
valores numericos ya sea de uno en uno, dos en dos, etc. Por ejemplo:
Sintaxis:
c= c+1; c=c+2; c=c-3……..etc.
Los contadores pueden expresarse enforma de suma o resta. Las dos

primeras variables deben ser iguales. El valor constante indica el numero
______________________________________________________ 53
Algoritmia
___________________________________________________
de conteo que ba ha realizar, si es uno indicara que el conteo será de uno
en uno y asi sucesivamente.
2.5. ACUMULADORES
Los acumuladores son otro tipo de variables muy utilizados dentro de
estructuras repetitivas. Su función principal es acumular valores
numericos que se an ingresado o procesado en alguna variable, etc. Por
ejemplo:
Sintaxis:
ac= ac + N ; t= t + M
Las dos primeras variables deben ser iguales siempre en un acumulador;

N y M son variables que contienen valores ya sea que se hayan
ingresado o calculado internamente dentro de una estructura repetitiva.
2.6. OPERADORES
Los operadores determinan el tipo de operación que se quiere
realizar con los elementos de una expresión. En una expresión, el
elemento sobre el cual actúa un operador se llama operando. Por
ejemplo, en la expresión, a + b, a y b son conocidos como operandos.
Los operadores pueden ser clasificados en las siguientes categorías:
 Operadores aritméticos
 Operadores Relacionales
 Operadores lógicos
Operadores Aritméticos
Los operadores aritméticos, como su nombre lo indica, son

utilizados para realizar cálculos aritméticos. Algunos de los
operadores aritméticos más comunes son los siguientes:
Operador Descripción Ejemplo
______________________________________________________ 54
Algoritmia
___________________________________________________
Suma (+) Suma los operandos c=a+b
Resta (-) Resta el operando derecho del c=a-b
operando izquierdo
Multiplicación Multiplica los operandos c=a*b
(*)
División (/) Divide el operando izquierdo c= a/b
por del operando derecho
Modulo (%) Calcula el residuo de una c= a%b
división entera
El siguiente pseudocódigo representa una operación usando el operador

modulo:
Inicio
Int nNum1, nNum2, nNum3
nNum1 = 15
nNum2 = 2
nNum3 = nNum1 % nNum2
Mostrar nNum3
Fin
En este pseudocódigo, a las variable nNum1 y nNum2 se le

asigna 15 y 2 respectivamente. La salida del pseudocódigo será 1, el
cual es el residuo de la división entera entre nNum1 y nNum2.
Operadores Relacionales
Se puede comparar dos operandos con el operadores relacional.

Cuando dos operandos son comparados usando estos operadores, el
resultado es un valor lógico, TRUE o FALSE.
Son seis operadores relacionales. La siguiente tabla muestra los
operadores relacionales:
______________________________________________________ 55
Algoritmia
___________________________________________________
Operador Descripción Ejemplo Explicación

= Evalúa si los operandos a=b Retorna TRUE si los
son iguales valores son iguales y
FALSE en caso
contrario.
!= Evalúa si los operandos a != b Retorna TRUE si los
son diferentes valores son diferentes y
FALSE en caso
contrario.
> Evalúa si el operando a>b Retorna TRUE si a es
de la izquierda es mayor que b y FALSE
mayor que el operando en caso contrario
de la derecha
< Evalúa si el operando a<b Retorna TRUE si a es
de la izquierda es menor que b y FALSE
menor que el operando en caso contrario
de la derecha
>= Evalúa si el operando a >= b Retorna TRUE si a es
de la izquierda es mayor o igual que b y
mayor o igual que el FALSE en caso
operando de la derecha. contrario
<= Evalúa si el operando a <= b Retorna TRUE si a es
de la izquierda es menor o igual que b y
menor o igual que el FALSE en caso
operando de la derecha contrario
Operadores Lógicos
Los operadores lógicos son usados para combinar los resultados de

expresiones que contienen operadores relacionales.
A continuación tenemos una tabla que describe los operadores lógicos:
Operador Descripción Ejemplo

AND Lógica a < 5 AND b > 10
AND
______________________________________________________ 56
Algoritmia
___________________________________________________
OR Lógica OR a < 5 OR b > 10
NOT Lógica NOT NOT a = 5
En la siguiente tabla se describe como trabaja el operador AND y el

operador OR:
Valor de la Expresión Combinada

Expresión 1 Expresión 2
AND OR
TRUE TRUE TRUE TRUE
TRUE FALSE FALSE TRUE
FALSE TRUE FALSE TRUE
FALSE FALSE FALSE FALSE
Precedencia de Operadores
Cada operador tiene una precedencia asociada. Se utiliza esta

característica para determinar la manera en que es evaluada una
expresión que implica más de un operador. Por ejemplo,
consideremos la siguiente expresión:
nResultado = nNum1 + nNum2 * nNum3 / 45
Para obtener el resultado correcto de tal expresión, es necesario saber la

prioridad o precedencia de cada operador.
La precedencia tiene diferentes niveles desde 1 hasta 8. Estos niveles

determinan el orden de evaluación de la expresión. Cada operador
pertenece a uno a un solo nivel y más de un operador pueden
pertenecer al mismo nivel. Los operadores de más alta precedencia se
evalúan primero. Los operadores del mismo nivel de precedencia se
______________________________________________________ 57
Algoritmia
___________________________________________________
evalúan de izquierda a derecha en una expresión. Esto se conoce como
asociatividad. La tabla siguiente lista los operadores en orden decreciente
de precedencia.
Nivel de
Operador Descripción Asociatividad Precedencia
() Paréntesis 1
! Lógica NOT 2
* Multiplicación
De Izquierda
/ División a Derecha 3
% Módulo
+ Suma De Izquierda
a Derecha 4
- Resta
< Menor que
<= Menor o Igual que De Izquierda

a Derecha 5
> Mayor que
>= Mayor o Igual que
= Igual que De Izquierda

a Derecha 6
! Diferente que
De Izquierda
AND Lógica “Y” a Derecha 7
De Izquierda
OR Lógica “O” a Derecha 8
______________________________________________________ 58
Algoritmia
___________________________________________________
Esta tabla muestra la precedencia y la asociatividad de los operadores.
El orden de precedencia y la asociatividad de los operadores tienen
que ser
evaluados mientras construimos la expresión para obtener la salida
deseada. Por ejemplo, consideremos la siguiente expresión:
nResultado = nNum1 + nNum2 * nNum3 / 45
De acuerdo a las reglas de precedencia, el operador de

multiplicación, "*", tiene la precedencia mas alta que al operador
suma "+" y el operador de división "/". Por lo tanto la multiplicación
de nNum1 y nNum2 se ejecuta primero. Asumiendo que los valores
de nNum1 es 8, nNum2 es 9 y nNum3 es 10, el resultado de la expresión
será:
nResultado = 8 + 90 / 45
El operador "/" tiene precedencia alta que "+". Por lo tanto, 90/45 es
evaluado primero.
El resultado de la expresión es:
nResultado = 8 + 2
El resultado final es:
nResultado = 10
En la expresión anterior, supongamos que el propósito era primero

sumar los números nNum1 y nNum2, y después multiplicar su resultado
con nNum3. Finalmente, dividir el resultado por 45. Para resolver
este propósito, se puede cambiar la orden de precedencia usando el
operador paréntesis "( )", tal como sigue:
______________________________________________________ 59
Algoritmia
___________________________________________________
nResultado = ( nNum1 + nNum2 ) * nNum3 / 45
CAPITULO III
APLICACIONES DE DIAGRAMAS DE FLUJO

Este capitulo le introduce al estudiante a conocer las diferentes
aplicaciones de los diagramas de flujo, planteando algoritmos, su
resolución y ejercicios propuestos para cada caso.
3.2. ESTRUCTURA SECUENCIAL

La estructura secuencial se caracteriza por mostrar problemas con
caracteristicas secuenciales donde por ningún caso se hara uso de alguna
otra estructura. Los problemas plantados mayormente tienen ambito
matematico ó aritmetico cumpliendo los tre requisitos basicos de un
diagarama: Entrada, Proceso y Salida.
______________________________________________________ 60
Algoritmia
___________________________________________________
Ejemplos:
Ejemplo 3.2.1:
Muestre un algoritmo lea dos valores a, b, y los intercambie. Por ejemplo si a = 2 y
b= 5, el algoritmo debe hacer que a = 5 y b= 2.
Solución:
Definición de variables:
a,b : variables cuyos valores se desean intercambiar.

t: variable de trabajo, sirve como almacenamiento temporal para evitar
que se pierda un valor mientras se realiza la asignación.
El algoritmo es sencillo, el único cuidado que hay que tener es

primero guardar el valor de una de las variables en una variable temporal tal y
como se muestra en el diagrama N/S. Si hubiéramos hecho a = b y luego b
=a, se perdería el valor inicial de a, en la primera asignación. Este tipo de
intercambio se denomina en los círculos informáticos swap y se utiliza con
frecuencia en ptros algoritmos más complejos tales como los de
ordenamiento.
Diagrama N/S
Leer a, b
t=a
a=b
b=t
Imprimir a, b
______________________________________________________ 61
Algoritmia
___________________________________________________
Ejemplo 3.2.2:
A una reunión asistieron n personas ¿Cuántos apretones de manos
hubieron?
Solución:
n : número de personas
a : número de apretones de mano
Se sabe que cada persona debe saludar a las (n - 1) restantes, por lo que habrá
n*(n-l) saludos como en cada saludo intervienen 2 personas la cantidad de
apretones de mano será:
a= n*(n-l)/2
Diagrama N/S
Leer n
a=n*(n- l)/2
Imprimir a
______________________________________________________ 62
Algoritmia
___________________________________________________
Ejemplo 3.2.3:
Hallar la suma de los n primeros números naurales
Solución:
n : cantidad de números naturales
s : suma de los primeros n números naturales
Se pide lo siguiente:
s = 1 + 2 + 3 + 4 + 5 + 6 + ...+ (n-4)+ (n-3)+ (n-2) +(n-l) + n
Escribamos esta expresión 2 veces una ascendentemente y la

otra descendentemente:
s = l + 2 + 3 + 4 + 5 + . . . + (n-4)+(n-3)+(n-2)+(n-l)+ n
s = n + (n-1) + (n-2) + (n-3) + (n-4) + . . . + 5 + 4 + 3 + 2 + 1
sumando miembro a miembro tenemos
De donde:
Diagrama N/S
Leer n
s = n*(n+l)/2
Imprimir s
______________________________________________________ 63
Algoritmia
___________________________________________________
Ejemplo 3.2.4:
Calcule la suma de los cuadrados de los primeros números naturales.
Solución:
s : suma de los cuadrados de los primeros n números naturales
s = l2 + 22 + 32 + 42+ 52 + 62 + . . . + (n - 4)2 + (n - 3)2 + (n - 2)2 + (n - l)2 + n2
Por binomio de Newton:

(2)3 = (l+l)3 = (1) 3 + 3(1)2(1) + 3(1)(1)2 + (l)3
(3)3 = (2+1)3 = (2)3 + 3(2) 2(1) + 3(2)(1)2 + (l)3
(4)3 = (3+1)3 = (3)3 + 3(3)2(1) + 3(3)(1)2 + (l)3
... = ... = .... + ... + ... + ...
... = ... = .... + ... + ... + ...
... = ... = .... + ... + ... + ...
(n-1)3 = (n-2+1)3 = (n-2)3 + 3(n-2)2(l) + 3(n-2)(l)2 + (l)3

(n)3 = (n-l+l)3 = (n-l)3 + 3(n-l)2(l) + 3(n-l)(l)2 + (l)3
(n+l)3 = (n-0+1)3 = (n)3 + 3(n ) 2 (1) + 3 ( n ) ( l ) 2 + (l)3
Sumando miembro a miembro y agrupando los términos que pertenecen a una
misma columna:
Simplificando y remplazando por sus equivalentes:
______________________________________________________ 64
Algoritmia
___________________________________________________
(n+1)3 = l3 + 3s + 3[ n(n+l)/2 ] + n
Reduciendo términos y factorizando nos queda:
Diagrama N/S
Leer n
s = n(n+l)
(2n+l)/6
Imprimir s
______________________________________________________ 65
Ejemplo 3.2.5:
Calcular la suma de los cubos de los n primeros números naturales.
Solución:
s : suma de los cubos de los primeros n números naturales
s = l3 + 23+ 33 + 43 + 53 + 63 + . .. + (n - 4)3 + (n - 3)3 + (n - 2)3 + (n - l)3 + n3
Por binomio de Newton:
(2)4 = (1+1)4 = (1)4 + 4(1)3(1) + 6(1)2(1)2 + 4(1)(1)3 + (1)4

(3)4 = (2+1)4 = (2)4 + 4(2)3(1) + 6(2)2(1)2 + 4(2)(1)3 + (1)4
(4)4 = (3+1)4 = (3)4 + 4(3)3(1) + 6(3) 2 (1)2 + 4(3)(1)3 + (1)4
... = ... = .... + ... + ... + ...

... = ... = .... + ... + ... + ...
... = ... = .... + ... + ... + ...
(n-1)4 = (n-2+1)4 = (n-2)4 + 4(n-2)3(l) + 6(n-2)2(l)2 + 4( n-2)(l)3 + (1)4

(n)4 = (n-l+l)4 = (n-l)4 + 4(n-l)3(l) + 6(n-l)2(l)2 + 4( n-l)(l)3 + (1) 4
(n+1)4 = (n-0+1)4 = (n)4 + 4( n )3(1) + 6( n )2 (1)2 + 4 ( n) (l)3 + (l)4
Sumando miembro a miembro y agrupando los términos que pertenecen a

una misma columna:
Simplificando y remplazando por sus equivalentes:

(n+1)4 = l4 + 4s + 6[ n(n+l)(2n+l)/6 ] + 4 [n(n+l)/2] + n
Reduciendo términos y factorizando nos queda:
Diagrama N/S
Leer n
s = {n(n+l)/2}2
Imprimir s
Ejemplo 3.2.6:
En un cuadrado cuyo lado es a, se unen los puntos medios de sus 4 lados,
formándose otro cuadrado cuyos puntos medios se unen también formando
otro cuadrado, y así sucesivamente. Calcule la suma de las áreas de todos
los cuadrados así formados.
Solución:
a: lado del primer cuadrado
s: suma de las áreas formadas
Cuad. Nº Lado Area

De la tabla adjunta se
1 a a 2 observa que la suma
pedida es:
s = a2 + a2/2 + a2/4 +
2 a2/2
a2/8 + ...
3 a2/4 que viene a ser una
progresión geométrica
4 a2/8 de infinitos términos,
cuyo primer término e
… … … donde: es a2, y cuya
razón es 1/2.
Factorizando 1/2 tenemos s = 1/2 ( 2a2 + a2 + a2 /2 + a2/4 + a2/8 +...)

observemos que a partir del segundo término la suma es igual a s, entonces
tenemos: s = 1 /2 ( 2a2 + s) de donde .
Diagrama N/S
Leer a
s=2a2
Imprimir
s
Ejemplo 3.2.7:
Calcule el área de un rombo de diagonales conocidas
Solución:
AreaRombo: área del rombo

d1: diagonal mayor
d2: diagonal menor
El área pedida viene dada por:

AreaRombo = Área del ΔABC + Área del ABCD
Conociendo que las diagonales de un rombo se bisecan mutuamente y que

son perpendiculares, y que el área de un triángulo cualquiera es:
Área del Δ = base . altura / 2
Tendremos: AreaRombo = d2 x (dl/2)/2 + d2x(dl/2)/2
De donde:
Diagrama N/S
Leer dl,d2
Calcular
AreaRombo=dl*d2/2
Imprimir
AreaRombo
Ejemplo 3.2.8:
Calcule el volumen de un cilindro recto conociendo su radio y su altura.
Solución:
VolCilindro: volumen del cilindro

r: radio de la base
h: altura
El volumen pedido está dado por:
VolCilindro = Area de la base x Altura
Esto es:
Diagrama N/S
Leer r, h
Calcular
VolCilindro= 3.14159*r*r*h
Imprimir
VolCilindro
Ejemplo 3.2.9:
Calcule el área total de un cilindro recto de radio y altura conocidos.
Solución:
AreaTota1Ci1: área total
del cilindro
r: radio de la base
h: altura
El Aárea pedida está dada

por:
AreaTota1Cil = Area de la
base + Area del techo + Area lateral
El área de la base y el área del techo, son iguales y vienen a ser el área de un
círculo:
Area de la base = Area del techo = π r2
El área lateral tiene la forma de un rectángulo cuyo largo es igual a la

longitud de la circunferencia o sea 2πr y, cuyo ancho es la altura del
cilindro, esto es:
Area lateral = 2πrh
Remplazando tenemos:
AreaTotalCil = πr2+ πr2+ 2πrh
donde:
Diagrania N/S
Leer r, h
AreaTotalCil= 6.28*r*(r+h)
Imprimir AreaTotalCil
Ejemplo 3.2.10
Se tiene una circunferencia de radio r, inscrita en un triángulo de lados a ,b,
c.
Encuentre el área de este triángulo en función de a, b, c y r.
Solución;
a, b, c: lados del triángulo
r: radio de
circunferencia inscrita
Sabiendo que el área

de un triángulo
cualquiera es:
Área del Δ = base . altura / 2
Tenemos:
Área del ΔABC = Área del ΔBOA + Área del ΔBOC + Área del
ΔAOC
de donde:
Diagrama N/S
Leer a, b, c, r
Calcular
area = (a + b + c).
r/2
Imprimir
area
Ejemplo 3.2.11:
El área del triangulo en función del semiperimetro, dada por Herón es:
, donde a, b y c son los lados del triángulo y
el semiperimetro. Calcular el área del triángulo aplicando
esta fórmula.
Solución:
AreaTriang: área del triángulo

a, b, c: longitudes de los lados
p: semiperímetro
Diagrama N/S
Leer a, b, c
p = (a+b+c)/2
Imprimir AreaTriang
Ejemplo 3.2.12:
En un triángulo rectángulo, calcule la longitud de la hipotenusa conociendo
las longitudes de sus catetos.
Solución:
a, b: catetos del triángulo rectángulo

c: hipotenusa
Por teorema de Pitágoras:
Diagrama N/S
Leer a, b
Calcular
c=
Imprimir c
Ejemplo 3.2.13:
El teorema del coseno es muy utilizado en geometría para calcular la
longitud del te rcer lado de un triángulo, cuando se conocen los otros 2 lados
y el ángulo que forman. Siendo a el lado desconocido, b y c los lados
conocidos, α el ángulo formado por b y c; el teorema del coseno se enuncia
como:
Calcule el tercer lado de un triángulo aplicando esteteorema.
Solución:
a: lado desconocido
b, c: lados conocidos
alfa: ángulo formado por b y c
Diagrama N/S
Leer b, c, alfa
Imprimir a
Ejemplo 3.2.14:
Calcule la distancia entre 2 puntos de coordenadas conocidas
Solución:
xl: abscisa del primer
punto
yl: ordenada del primer
punto
x2: abscisa del segundo
punto
y2: ordenada del segundo
punto
Sabemos que la distancia entre 2 puntos de coordenadas (xl, yl) y (x2, y2)
está dada por:
Diagrama N/S
Leer xl, x2, yl, y2
Imprimir d
Ejemplo 3.2.15:
Convierta el complejo c =a + bi, a sus coordenadas polares.
Solución:
ω: ángulo formado por recta que
une (a, b) con el origen (0,0).
a : parte real del complejo
b : parte imaginaria del complejo
ρ: distancia del punto al origen
Un número complejo puede ser presentado en el plano cartesiano

onsiderando que su Parte Real se ubica en el Eje X, mientras que su Parte
Imaginaria n el Eje Y. Teniendo en cuenta esto, una forma alternativa de
escribir el complejo c =a + b i, es ponerlo en función del ángulo ω ue forma
el punto (a, b) con el eje real y de la distancia ρ del mismo punto al origen.
Diagrama N/S
Del gráfico tenemos:
Leer a, b
ω=arctg(b/a)
Imprimir ω, ρ
Reemplazando en la ecuación original c = a + bi, nos queda
En donde :
(ω y ρ son conocidas como coordenadas polares, teniendo en cuenta que

para representar un punto solo se necesita un ángulo y la distancia del punto
de origen)
Ejemplo 3.2.16:
¿Cuál es el monto a devolver si nos prentan un capital c, a una taza de
interes t%, durante n periodos?
Solución:
c : capital tomado en préstamo
t : tasa de interés en decimales
n : número de periodos
m: monto a devolver
Sabemos que:
m = c(l+t)n
Diagrama N/S
Leer c, n t
m =c (l +t)n
Imprimir m
Ejemplo 3.2.17:
En todo triángulo se cumple que cada lado es proporcional al seno del
ángulo opuesto. Esta ley se llama “ley de los senos", matemáticamente:
Si se conocen los ángulos α, β, y γ el lado c, ¿cuánto

valen los otros dos lados?
Solución:
a, b, c : lados del triángulo
α, β y γ: ángulos opuestos a a, b y c respectivamente
Despejando de la fórmula:
Diagrama N/S
Leer c, alfa, beta, gamma

a = c*sen (alfa) / sen
(gamma)
b = c*sen (beta) / sen(gamma)
Imprimir a, b
Ejemplo 3.2.18
Existen muchas maneras de medir ángulos. El Sistema Sexagesimal divide
circunferencia en 360 partes llamándola a cada una "grado sexagesimal”
cada grado sexagesimal está dividido en 60 minutos y cada minuto en 60
segundos, (por ejemplo 20°15’21").
El Sistema Centesimal considera como unidad de medida "el grado
centesimal" y equivale a la 400 ava. parte de la circunferencia, cada grupo
centesimal está dividido en 100 minutos centesimales y cada minuto en 100
segundos centesimales, (por ejemplo 20g15m21s).
El Sistema Radial utiliza como unidad de medida un arco cuya longitud es
igual a su radio, como la longitud de la circunferencia es l = 2πr; en
trigonometría se considera un círculo base con radio r = 1, entonces toda la
circunferencia tendrá 2π radianes.
Deduzca la relación entre los diferentes sistemas de medidasde ángulos, use
la proporción entre la cantidad de grados requeridos y el total degrados de
toda la circunferencia.
Teniendo en cuenta esta relación, escriba un programa que lea ángulo en

grados sexagecimalesy diga cuál es su medidas en los sistemas centesimal y
radial.
Solución:
Definición de variables
S : ángulo en grados sexagesimales

C : ángulo en grados centesimales
R : ángulo en radianes
S, C y R representa al mismo ángulo pero en diferentes sistemas.
Es obvio que la cantidad de grados en cada sistema es proporcional al total de

grados de la circunferencia en dicho sistema ("El arco chico es al arco
grande en un sistema, como el arco chico es al arco grande en otro
sistema").
Por lo que:
Diagrama N/S
Leer S
C = (10/9)*S
R = (π/180)*S
Imprimir C, R
Ejemplo 3.2.19:
Convierta el ángulo sexagesimal UºV´W” a grados, minutos y segundos.
Solución: Diagrama N/S
U: grados sexagesimales del ángulo Leer U,V,W

V: minutos sexagesimales del ángulo
W: segundos sexagesimales del S = U +V/60 + W/3600
ángulo
S: valor en grados sexagesimales C = 10*S/9
C: valor en grados centesimales
gra : grados centesimales del ángulo gra = entero (C)
min: minutos centesimales del ángulo
seg : segundos centesimales del min = entero((C-gra)*100)
ángulo
seg = ((C-gra)*l00)-min)*100
Convirtiendo a grados sexagesimales:
S = U + V/60 + W/3600 Imprimir gra, min, seg
Convirtiendo S grados sexagesimales, a C grados centesimales: C = 10*S/9
Convirtiendo C grados centesimales a grados, minutos y segundos

centesimales
gra = entero(C)
min =entero((C-gra)* 100)
seg =( (C-gra)*100-min)*100
Ejemplo 3.2.20:
Para medir la temperatura existen 4 escalas, las cuales guardan la siguiente
proporción:
Si C, F, K y R, son los valores de una misma temperatura en grados Celsius

(Centígrados), Farenheit, Kelvin y Rankine respectivamente, deduzca las
fórmulas para convertir una temperatura de una escala a otra.
Luego lea una temperatura en grrados Celsius y diga a cuántos grados

equivale en Farenheit, Kelvin y Rankine.
Solución:
a, b: longitudes cualesquiera de la escala
C : valor de la temperatura en grados Celsius
F : valor de la temperatura en grados Farenheit
K : valor de la temperatura en grados Kelvin
R : valor de la temperatura en grados Rankine
Del gráfico y utilizando segmentos proporcionales:
De donde:
Finalmente:
F = (9/5) C + 32
K = C +273
R = (9/5) C + 492
Diagrama N/S
Leer C
F = (9/5)*C + 32
K = C + 273
R = (9/5)*C +
492
Imprimir F, K, R
Ejemplo 3.2.21;
Haga un diagrama N/S que permita leer 3 temperaturas una en ºF, otra en K
y la otra en ºR y las convierta a sus equivalentes en grados Celsius.
Solución:
F : temperatura ingresada en grados Farenheit

K : temperatura ingresada en grados Kelvin
R : temperatura ingresada en grados Rankine
CF : temperatura F en grados Celsius
CK: temperatura K en grados Celsius
CR : temperatura R en grados Celsius
De la relación encontrada en el problema interior, tenemos:
CF= (5/9)(F-32)
CK = K – 273
CR= (5/9)(R-492)
Diagrama N/S
Leer F, K, R
CF = (5/9)*(F-32)
CK = K - 273
CR = (5/9)*(R-492)
Imprimir CF, CK,
CR
Lea atentamente cada enunciado y plantee su solución. Luego construya un
diagrama N/S.
1) Calcule la longitud de una circunferencia de radio conocido.

2) Calcule el área de un trapecio cuyas base menor, base mayor y altura
son conocidas.
3) Sabiendo que una milla equivale a 1609 Kilómetros, lea una cantidad
en millas y conviértala a kilómetros.
4) Calcule el perímetro de un rectángulo.
5) Calcule el perímetro de un triángulo rectángulo si se conocen sus
catetos.
6) ¿Cuál es el volumen de un paralelepípedo de largo, ancho y altura
conocidos?
7) ¿Cuál es el área total de un palalelepípedo?
8) Calcule el área de un triángulo cuando se conocen 2 lados y el
ángulo que forman.
9) En todo triángulo se cumple que cada lado es proporcional al seno de
ángulo opuesto. Esta ley se llama "ley de los senos", matemáticamente:
Si se conocen los lados a, b, c, y γ ¿cuánto

valen los otros dos ángulos?
10) En un campeonato de fútbol participan n equipos. ¿Cuántos partidos

habrán en la primera rueda del campeonato?.
10) Calcule la suma de los n primeros números pares.
11) Calcule la siguiente suma: s = 1*2 + 2*3 + 3*4 +... + n*(n+l).
12) Calcule la siguiente suma: s = 1+3 +5 + 7 + ... + (2n -1).
11) Lea una temperatura en grados Kelvin y conviértela a grados Celsius,
Farenheit y Rankine.
12) Lea 3 temperaturas una en grados Celsius, otra en Kelvin y otra Rankine
y conviértalas a Farenheit.
13) Lea una hora y diga a cuántas horas, minutos y segundos equivale.
14) Lea el ángulo en radianes y conviértalo a grados, minutos y segundos
sexagesimales.
15) Convierta el ángulo centesimal XgYmZs a grados sexagesimales. No
considere minutos, ni segundos sexagesimales.
16) Lea dos números. El primero representará el día y mes de su nacimiento
(por ejemplo 1 de julio será 107), el segundo número vendrá dado por su
edad, luego realice los siguientes cálculos: Multiplique el primer número
por 2, Adiciónele 5, multiplíqueío por 50, súmele el segundo número,
súmele 365 y réstele 615. El resultado vendrá a ser la unión del primer
número con el segundo. Este juego es conocido en los círculos
matemáticos como "juego de sociedad".
17) En un cuadrado cuyo lado es a, se unen los puntos medios de sus 4
lados, formándose otro cuadrado cuyos puntos medios se unen también
formando otro cuadrado, y así sucesivamente. Calcule la suma de los
perímetros de todos los cuadrados así formados.
18) Un inversionista está pensando invertir C dólares a una tasa de interés
T. ¿Cuántos periodos (N) necesita para tener al final M dólares.
19) ¿A cuánto dinero de hoy (C) equivalen M dólares del futuro, sabiendo
que la tasa de interés es T y el número de periodos N.
20) ¿Cuántas billetes de 5, 10, 20, 50 y 100 soles y monedas de 0.01, 0.05,
0.1, 0.5 y 1 sol recibirá un empleado como pago por su trabajo?. Suponga
que se le debe entregar la máxima cantidad posible de billetes y monedas
de cada denominación.
21) Calcule la media aritmética de los n primeros números enteros positivos.
3.3. ESTRUCTURA CONDICIONAL SIMPLE
La estructura condicional simple se caracteriza por mostrar problemas en
base a preguntas, con respuestas para un caso verdadero y falso y en
algunas veces solo para casos verdaderos, dependera mucho del
algoritmo que se propone.
Ejemplos:
Ejemplo 3.3.1:
Elabore un algoritmo que resuelva una ecuación de primer grado.
Solución:
a: coeficiente de x. Debe ser diferente de 0.

b: término independiente
La solución es bastante simple, una ecuación de primer grado es de la

forma: ax + b = 0, de donde despejando x tendremos: x = -b/a, debiendo
considerar que para que exista solución a ≠ 0.
Diagrama N/S
Leer a, b
a==0
V
Imprimir "No x = -b/a
es de primer Imprimir
grado" X
Ejemplo 3.3.2:
Una llamada telefónica en cualquier teléfono público cuesta S/. 0.50 por los
primeros 3 minutos o menos. Cada minuto adicional es un paso de contador
y cuesta S/.0.l.Calcule el monto de una llamada cualquiera.
Solución:
duración: duración de la llamada
costo: costo total de la llamada
Si la duración de la llamada es menor a 3 minutos entonces la llamada cuesta

0.5, mientras que si excede los 3 minutos costará 0,5 por los primeros 3
minutos y 0.1 por los (duracion-3) minutos adicionales.
Diagrama N/S
Leer duración
duración <= 3
V F
costo = 0.5 costo = 0.5 + 0.1 (duracion-3)
Imprimir
costo
Ejemplo 3.3.3:
Una llamada de un teléfono fijo a otro, también fijo, en HORARIO NORMAL
(todos los días de 7:00 a 22:59 horas), cuesta sin IGV S/. 0.078, mientras
que en el HORARIO REDUCIDO (todos los días de 23:00 a 6:59hrs), cuesta
sin IGV S/. 0.039 hrs.
Calcule el costo total de una llamada teléfonica si considera 1 minuto

adicional al cargo por establecimiento de llamara y solo se considera la
hora de inicio para determinar a que tarifa se sujeta.
Solución:
hora: hora de inicio de la llamada
min: minuto de inicio de la llamada
inicio: minuto de inicio en el día
dura: duración de la llamada
El horario normal comienza en el minuto 7x60 = 420 del día y termina en el

minuto 22x60+59 = 1379 del día. Toda hora de inicio válida que no este en
este rango se realiza en horario reducido.
Por lo tanto, basta con preguntar si la hora de inicio en minutos esta dentro de
ese rango y calcular el costo total de la llamada. Además hay que tener en
cuenta que el impuesto general a las ventas es de 18%.
Diagrama N/S
Leer hora, min, dura

inicio = hora*60 + min
inicio>419 AND inicio <1380
V
F
Costo=(dura + 1)*0.078 Costo=(dura + 1)*0.039
Imprimir
1.18*costo
Ejemplo 3.3.4:
Un número puede ser menor, igual o mayor que otro. Describa describa un
algoritmo que lea 2 números y determine cómo es uno respecto a otro.
Solución:
a, b: números ingresados
Podemos hacer las comparaciones tal como se muestra en el diagrama N/S.
Diagrama N/S
Leer a, b
a==b
V
Imprimir a>b
a, "es V
igual a", b Imprimir Imprimir b,
a, "es mayor "es mayor
que", b que", a
Ejemplo 3.3.5:
Ordene de mayor a menor, 3 números ingresados por teclado.
Solución:
Definición de variables: a, b, c : números que deseamos ordenar.
Como se trata de 3 números, sabemos que existen 3! = 3x2x1 = 6

posibilidades de ordenarlos.
Teniendo en cuenta esto las posibles ocurrencias serán:
Diagrama N/S
Leer a, b, c
a ≥ b AND b ≥ c
V F
Imprimir a ≥ c AND c ≥ b
a, b, c V F
b ≥ a AND a ≥ c
V F
Imprimir b≥c AND c≥a
Imprimir b, a, c V F
a, c, b c≥ a AND ≥b
Imprimir V F
b, c, a Imprimir Imprimi r
c, a, b c, b, a
Ejemplo 3.3.6:
Encuentre el mayor valorde 3 números dados
Solución:
a, b, c: números que deseamos evaluar
Podemos ir comparándolos de 2 en 2 tal como se observa en el diagrama N/S.
Diagrama N/S
Leer a, b, c
a≥b
V F
a≥c b≥c
V F V F
m=a m=a m=a m=a
Imprimir m
Ejemplo 3.3.7
Elabore un algoritmo que obtenga las raices reales de una ecuación de
segundo grado.
Solución:
Diagrama N/S
a: coeficiente de x2. Leer a, b, c

Deber ser diferente de
a≠0
0.
V F
b: coeficiente de x. d = b2 - 4ac
c: término independiente. d >=0
d: discriminante b2 - 4ac. V F Imprimir
Debe ser diferente de 0 "Coefic.
xl: primera raíz real. xl=(-b + )/(2a)
de x2
x2: segunda raíz real. Imprimir debe ser
x2= (-b - )/(2a)
"raíces diferente
La forma general de una imaginarias” de cero"
Imprimir
ecuación de segundo
xl,x2
grado es: ax2+bx+c=0
Completando cuadrados:
ax2 + bx =-c multiplicando por 4a 4a2x2 + 4abx = - 4ac sumando b2 a ambos
lados
4a2x2+ 4abx+b2=-4ac + b2
factorizando:
(2ax + b)2 = b2 - 4ac 2ax + b =
de donde:
Para que exista solución, (para poder dividir) y b2 - 4ac ≥ 0, (para

obtener la raíz cuadrada).
Ejemplo 3.3.8:
Un año bisiesto es aquel que tiene 366 días. Mediante un decreto del Papa
Gregorio XIII, dado en 1582, se reforma el Calendario Juliano que nos
regía, para que pasen a considerarse bisiestos aquellos años múltiplos de 4,
pero no los múltiplos de 100, excepto los múltiplos de 400. Escriba un
algoritmo que diga si un año es o no bisiesto.
Solución:
annio: Año del que deseamos determinar si es bisiesto.
Debemos saber que el operador MOD obtiene el resto de la división

entera.
Si dicho resto es igual a cero entonces el primer operando es divisible por el
segundo.
Según el enunciado annio, será bisiesto si:

Es múltiplo de 4, lo que se escribe (annio MOD 4 = =0), pero no múltiplo
de 100, excepto los múltiplos de 400 que si son bisiestos
(annio MOD 100 ≠ 0) OR (annio MOD 400 == 0)
Combinando ambas condiciones, tendremos la condición de bisiesto:
(annio MOD 4 == 0) AND ((annio MOD 100 ≠ 0) OR (annio MOD
400== 0))
Diagrama N/S
Leer annio
(annio MOD 4 == 0) AND

((annio MOD 100 ≠ 0) OR
(annio MOD 400 == 0)
V F
Imprimir Imprimir
"Año no bisiesto" "Año Bisiesto"
Ejemplo 3.3.9:
Los 3 números q, r y s, y determine si q es el multiplo de r y s.
Solución:
q: número cualquiera
r, s: posibles divisores
q será múltiplo de r y de s cuando r y s dividan exactamente a q, esto es

cuando el resto de la división entera sea cero para ambos casos.
Diagrama N/S
Leer q, r, s
(q MOD r==0)AND
(q MOD s == 0)
V F
Imprimir Imprimir
q, " es múltiplo de ", r, q, " no es múltiplo de ",
" y de ", s r, " y de ", s
Ejemplo 3.3.10:
Conociendo x, encuentre el valor numérico de la siguiente expresión:
Solución:
x: variable independiente
y: variable dependiente
Diagrama N/S
Leer x
x == 5 OR x = -5
V F
y = (x-3)/(x2-25)
Imprimir "lo siento, la
función es discontinua
en ese punto" Imprimir
y
La función no puede calcularse para x = 5 ó x = -5, pues el divisor (x 2 -25), se

hace igual a cero, por lo tanto si x es igual a 5 ó -5 deberá mostrarse el mensaje
adecuado.
Ejemplo 3.3.11
Muestre un algoritmo que nos permita evaluar la función.
Solución:
x: variable independiente
y: variable dependiente
El diagrama N/S muestra la implementación del algoritmo.
Diagrama N/S
Leer x
x <= 0
V F
x <= 8
y = x + sen x V F
y = 2x - ln x y = log(x-8)
Imprimir y
Ejemplo 3.3.12:
Dados 3 longitudes, diga si pueden formar un triángulo.
Solución:
a, b, c: lados del triángulo.
Debemos tener en cuenta el siguiente teorema: "En todo triángulo, cada

lado es menor que la suma de los otros dos, pero mayor que su diferencia".
Suponga que desea atravesar un cerro. Si pasa por el túnel que tiene una
longitud a, recorrerá menor distancia que si sube la pendiente b y baja por la
c.
Matemáticamente: a< b + c. Esto debe cumplirse tanto cuando a sea la
longitud del túnel, como cuando b ó c lo sean. De donde deducimos que para
que exista el cerro (triángulo) debe cumplirse que:
a< b + c
b< a + c
c< a + b
Observe además como de estas expresiones podemos obtener: c >a-b, a>b-c,

b>c-a; como han sido deducidas de las primeras, basta verificar el primer
grupo de expresiones para considerar que las tres longitudes forman un
triángulo.
Diagrama N/S
Leer a, b, c
(a < b + c) AND (b < a + c) AND (c < a+ b)
V F
Imprimir Imprimir
“Forman triángulo” “No forman triángulo”
Ejemplo 3.3.13:
Dados 3 longitudes, compruebe si pueden formara un triángulo y luego
clasifiqueel triángulo según sus lados.
Solución:
a b, c: lados del triángulo.
La primera parte del problema se resolvió en el ejercicio anterior.
En cuanto a la clasificación de triángulos según lados recordemos

lo siguiente:
Triángulo Equilátero: Es aquel triángulo cuyos tres lados son iguales.

Triángulo Isósceles : Es aquel triángulo que tiene dos lados iguales.
Triángulo Escaleno : Es aquel triángulo que tiene sus tres lados diferentes.
Diagrama N/S
Leer a, b, c
(a < b + c) AND (b < a + c) AND (c < a+ b)
V F
(a == b) AND (b == c)
V F
(a == b) AND (b == c)
OR (a == c) Imprimir
Imprimir
V F “No forman
“Triángulo
Imprimir Imprimir triángulo”
equilátero”
“Triángulo “Triángulo
isósceles” escaleno”
Ejemplo 3.3.14:
El rendimiento de un alumno se califica según lo siguiente:
Bueno si su promedio esta entre 16 y 20
Regular si su promedio está entre 11 y 15
Deficiente si su promedio está entre 6 y 10
Pésimo si su promedio está entre O y 5
Escriba un algoritmo que lea el promedio de un alumno y diga cuál es su
rendimiento.
Solución:
Prom:
Es la nota Promedio del alumno.
Diagrama N/S
Leer prom
(prom <0) OR (prom >20

V F
prom <=5
V F
Imprimir prom <=10
Imprimir "redimiento V F
"datos pésimo" prom <=15
erróneos" Imprimir V F
"rendimiento Imprimir Imprimir
deficiente" "rendimiento "rendimiento
regular" bueno'
Ejemplo 3.3.15:
Lea un número y obtenga el signo, su parte entera y su parte fraccionaria.
Solución:
x: Es el número a evaluar
Para obtener el signo, basta con preguntar si es mayor que cero, en cuyo caso
será positivo, encaso contrario será negativo. Todos los lenguajes de
programación incluyen funciones que obtienen la parte entera de un número.
En C++, esta función es floor().
Diagrama N/S
Leer x
x >= 0
V F
Imprimir Imprimir
“signo positivo" "signo negativo”
Imprimir
"Parte entera", entero (x)
"Parte fraccionaria", x - entero(x)
Ejemplo 3.3.16:
Si compramos por mayor100 o más articulos nos descuentan el 40%, si
compramos entre 25 y 100 nos descuentan un 20%, y si compramos entre10 y
25 un 10%. No hay descuento si adquirimos menos de 10 artículos. Diga
cuanto debemos pagar por nuestra compra.
Solución:
x: cantidad de artículos.
p: precio unitario del artículo.
d: descuento obtenido.
y: monto a pagar.
Las condiciones están descritas en la siguiente función de descuento:

0.40 si x >= 100
d(x) 0.20 si 25 <= x < 100
0.10 si 10<=x<25
0.00 si x<10
El monto a pagar será y = p*x*(l-d)
Diagrama N/S
Leer x, p
x >= 100
V F
d = 0.40 x >= 25
V F
x >= 10
V F
d = 0.20 x >= 0
d = 0.10 V F
d = 0.0
Imprimir
y = p * x * (1 - d)
“cantidad erronea”
Imprimir y
Ejemplo 3.3.17:
Si el sueldo de un empleado es de 1000 o menos se le descuenta el 10%. Si
esta entre 1000 y 2000 el 5% sobre el adicional, y si está arriba de 2000, el
3% sobre el adicional. Ecriba un algoritmo que lea el sueldo y muestre el
salario neto y el impuesto.
Solución:
sb: sueldo bruto del trabajador.
d: descuento al sueldo.
sn: sueldo neto del trabajador.
En este caso si el trabajador gana más de 1000 y hasta 2000, el descuento por
los primeros 1000 se mantendrá en 10% lo que equivale a 0.1*1000=100,
mientras que el descuento por lo que gana arriba de 1000 será 0.05(sb-1000).
Lo mismo ocurre cuando el trabajador gana más de 2000, puesto que se le
descuento 0.1*1000 = 100 por los primeros 1000, y 0.05*(2000-1000)=50,
por los siguientes 1000, el descuento será 100+50 +0.03(sb-2000).
Estos casos de descuentos adicionales por lo general se aplican en el caso de
pago de impuestos, con la intensión de que el pago sea más equitativo.
Entonces tenemos:
Si sb<=1000, d = 0.1sb
Si 1000<sb<=2000, d=l 00+0.05(sb-1000)
Si sb> 2000, d=150+0.03(sb-2000)
El salario neto será sn = sb -d
Diagrama N/S
Leer sb
sb<0
V F
sb<=1000
Imprimir V F
"sueldo
d=0.1*s sb<=2000
bruto
b V F
incorrect
d=l00+0.05(sb-1000) d=150+0.03(sb-2000)
o
sn = sb -d
Imprimir sb, sn, d
Ejemplo 3.3.18:
Dada la hora y el día en horas, minutos y segundos encuentre la hora del
siguiente segundo.
Solución:
h: horas
m: minutos
s: segundos
Si h, m y s, representan una hora válida, entonces el siguiente segundo será

s+1, el cual si llega a ser 60 hará que m aumente en 1, si m llega a ser 60
hará que h aumente en 1, si h llega a ser 24, entonces debemos hacer h = 0
pues habrá terminado el día. Esto se muestra en el diagrama N/S.
Diagrama N/S
Leer h, m, s
s = s +1
s==60
V F
s =0
m=m+1
m==60
V F
m=0
h = h+l
h==24
V F
h=0
Imprimir h, m, s
Ejercicíos Propuestos:

diagrama N/S.
1) Diga si un número es par o impar.

2) Obtenga el valor absoluto de un número.
3) Si dos números son positivos calcule su producto, en caso contrario
calcule su suma.
4) Sin usar estructuras repetitivas, lea 5 números y determine el menor.
5) Lea 5 números y diga si están ordenados ascendentemente.
6) Ordene 3 números a, b y c, de tal manera que al final a, sea siempre el
mayor, b, sea el intermedio y c el menor.
7) Elabore un algoritmo que obtenga las raíces de una ecuación de segundo
grado, contemplando el caso de raíces imaginarias.
8) Dados 3 longitudes, compruebe si pueden formar un triángulo y luego
clasifique el triángulo según sus ángulos.
9) Muestre un algoritmo que lea 3 números a, b y c, y determine si pueden
formar un triángulo comprobando que p>a, p>b y p>c, donde p es el
semiperímetro y equivale a p= (a+b+c)/2. Luego calcule el área del
triángulo usando la fórmula de Herón
10) Muestre un algoritmo que nos permita evaluar la función
11) Lea 2 enteros a, b, y obtenga el valor numérico de la función:

12)Diga si un número n es múltiplo de m.
13)Lea 3 números e indique cual es el valor intermedio.
14) Dada la hora en horas, minutos y segundos encuentre la hora del segundo
anterior.
15) En una Universidad tienen como política considerar 3 notas en cada
curso la nota de trabajos T, la nota de medio ciclo M y la de fin de ciclo
F, cada una tiene un peso de 50%, 20% y 30% respectivamente. Un
alumno es calificado según lo siguiente:
Bueno si su promedio esta entre 16 y 20
Regular si su promedio está entre 11 y 15
Malo si su promedio está entre 6 y 10
Pésimo si su promedio está entre O y 5
Escriba un algoritmo que lea las 3 notas de un alumno y en un curso y
diga cómo ha sido catalogado el alumno.
16) Los trabajadores de una fábrica tienen 3 turnos: mañana, tarde y noche.
La tarifa de los turnos de mañana y tarde son iguales, mientras que de
noche son 30% mayores. Construya un diagrama que lea el número de
horas laboradas por un trabajador y la tarifa calcule el salario semana
Considere que durante la semana el trabajador se encuentra siempre en el
mismo turno.
17) Un trabajador es contratado bajo las siguientes condiciones. Por las horas
normales se le paga una tarifa fija. Se consideran horas normales a todas
las horas trabajadas hasta un total de 140 al mes. Las horas adicionales a
140 se consideran como extras y una hora extra se paga el equivalente
1.5 horas normales. Los impuestos están en función del monto obtenído
por el trabajador. Si el sueldo es menor o igual a S/. 20,000 no paga
impuestos, por los siguientes S/. 20,000 paga el 10%, mientras que para
montos mayores a S/. 40,000 paga el 15% sobre el adicional. ¿Cuál es el
sueldo neto del trabajador y cuál es el monto en impuestos que debe
pagar?
18) Una llamada de un teléfono fijo a otro, también fijo, en HORARIO
NORMAL (todos los días de 7:00 a 22.59 hrs), cuesta sin IGV S/. 0.078
mientras que en HORARIO REDUCIDO (todos los días de 23:00 a 6:59
hrs), cuesta S/. 0.039. Calcule el costo total de una llamada telefónica,si
considera 1 minuto adicional de cargo por establecimiento de llamada.
Si la llamada se realiza justo en la transición de un horario a otro,
calcule el monto según cuantos minutos se realizaron en cada horario.
19) Dado un número de día de un determinado año, encuentre el día, mes y
año al que corresponde. Por ejemplo el día número 300 del año 2000 es
el 26/10/2000.
3.4. ESTRUCTURA DE SELECCIÓN MULTIPLE
La estructura de selección multiple se caracteriza por agrupar varios
problemas en casos diferentes. Una estructura de selección tambien es
utilizada para problemas con respuestas multiples.
Ejemplos:
Ejemplo 3.4.1:
Construya una calculadora que lea 2 números y un operador, y efectue la
operación indicada. La calculadora será capaz de realizar las siguientes
operaciones: + (surna), - (resta), * (multiplicación), / (división) y # (potencia)
Solución:
n1: primer operando

n2: segundo operando
op: operador
r: resultado
Diagrama N/S
Leer n1, op, n2

op
'+' `-` ´*´ ´/´ '#' otro caso
r=nl+n2 r= nl-n2 r=nl*n2 r= nl/n2 r=(nl)n2 "Operador

no
Imprimir r definido"
Ejemplo 3.4.2:
Los signos del zodiaco son 12: aries (marzo 21 - abril 20), tauro (abril 21 –
mayo 20 ), géminis (mayo 21 -junio 21), cáncer (junio 22 -julio 22), leo (julio
23 - agosto 22), virgo (agosto 23 - setiembre 22), libra (setiembre 23),
escorpio (octubre 23 - noviembre 21), sagitario (noviembre 22 -
diciembre 21), capricornio (diciembre 22 - enero 20), acuario (ener 21 –
febrero 19) y piscis (febrero 20 - marzo 20). Escriba un programa que lea el
día y mes de su nacimiento y determine a que signo pertenece.
Solución:
día: día de nacimiento
mes: mes de nacimiento
Diagrama N/S
Leer día, mes
mes ___
otro
caso
1 2 3 4 5 6 7 8 9 10 11 12
día<21 día 20 dia<21 dia<21 dia<21 dia<22 dia<23 dia<23 dia<23 dia<21 dia<22 dia<22 E
r
V V F V F V F V F V F V V F V F V F V F V F r
F F o
r
"Capricornio"
"Escoprpio"
“capricornio”
"Sagitario"
"Sagitario"
"Géminis"
"Escopio"
"Gemins"
"acuario"
"acuario"
"Cáncer"
"Cáncer"
"Virgo"
"Virgo"
"piscis"
"piscis"
"Libra"
"Libra"
"tauro"
"tauro"
"aries"
"aries"
"Leo"
"Leo"
Ejemplo 3. 4.3
Lea un día y un mes cualquiera y determine a que estación pertenece.
Considere que primavera inicia el 23 de setiembre, verano inicia el 21 de
diciembre, otoño empieza el 21 de marzo e invieno el 22 de junio.
Solución:
Definición de variables: día: día; mes: mes
Diagrama N/S
Leer día, mes

mes
1 2 3 4 5 6 7 8 9 10 11 12 Otro caso
día<21 día<22 día<23 día<21
VF V F V F V F “mes incorrecto”
“Verano" “Otoño” “Invierno” “Primavera” “Verano”
Ejemplo 3.4.4:
Lea un mes y un año y determine cuántos días tiene ese mes.
Solucion:
m: mes
a: año
días: número de días que tiene el mes.
Podemos construir nuestro diagrama N/S sabiendo que enero, marzo, mayo,
julio, agosto, octubre y diciembre tienen 31 días, y que abril, junio, setiembre
y noviembre 30 días, además febrero tendrá 28 ó 29 días, según sea un año
normal o un año bisiesto respectivamente.
La expresión que evalúa si un año es bisiesto es:
(a%4 = = 0)&&((a%100!=0) ‌ (a%400= =0))
La cual puede ser escrita de manera más como:
! (a%4)&& (a%100)|| !(a%400)
Diagrama N/S
Leer m, a
m
1 3 5 7 8 10 12 4 6 9 11 2
(a MOD 4 = = 0) AND
((a MOD 100 ≠ 0= OR
(a MOD 400 = = 0))
días = 31 días = 30
V F
días = 29 días = 28
Imprimir días
Ejemplo 3. 4.5:
Lea tres números que representen el día, el mes y el año, y diga si forman una
fecha correcta. Considere años bisiestos
Solución:
día: día de la fecha a verificar.

mes: mes de la fecha a verificar.
a: año de la fecha a verificar,
maxdía: máximo día permitido para ese mes
Diagrama N/S
Leer día, mes, a

mes
1 3 5 7 8 10 12 4 6 9 11 2
(a MOD 4 = = 0) AND
((a MOD 100 ≠ 0= OR
(a MOD 400 = = 0))
maxdía = 31 maxdía = 30
V F
(día>0) AND (día<=maxdía) AND (mes>0)
AND (mes<13) AND (a>0))
V F
Imprimir Imprimir
"la fecha es correcta" "la fecha es incorrecta"
Ejemplo 3.4.6:
Dada una fecha válida determine la fecha del día siguiente.
Solución:
dia: día de la fecha ingresada.

mes: mes de la fecha ingresada.
a: año de la fecha ingresada.
maxdia: máximo día permitido para ese mes
Diagrama N/S
Leer día, mes, a

mes
1 3 5 7 8 10 12 4 6 9 11 2
(a MOD 4 = = 0) AND
((a MOD 100 ≠ 0= OR
(a MOD 400 = = 0))
V F
día = día + 1
dia > maxdia
V F
día = 1
mes = mes + 1
mes = = 13
V
F
mes = 1
a=a+1
Imprimir "Fecha día siguiente:", día, mes, a
Ejemplo 3.4.7:
Lea un número menor a 4000 y conviértalo a números romanos.
Solución:
n: número arábigo que deseamos mostrar en romanos.
El diagrama N/S muestra el algoritmo pedido. Debe tener en cuenta que el
operador MOD devuelve el resto de la división entera, mientras que el
operador DIV devuelve el cociente entero de la división entera.
Diagrama N/S
Leer n
unidades = n MOD 10 n = n DIV 10
decenas = n MOD 10 n = n DIV 10
centenas = n MOD 10 n = n DIV 10
millares = n MOD 10
1 mi11ares
2 3
Imprimir Imprimir Imprimir
"M" "MM" "MMM"
Centenas
1 2 3 4 5 6 7 8 9
Imprimi Imprimir Imprimir Imprimir Imprimir Imprimir Imprimir Imprimir Imprimir
r "C" "CC" "CCC" "CD" "D" "DC" "DCC" "DCCC" "CM"
Decenas
1 2 3 4 5 6 7 8 9
Imprimi Imprimir Imprimir Imprimir Imprimir Imprimi Imprimi Imprimi Imprimir
r "X" "XX" "XXX" "XL" "L" r "LX" r "LXX" r "XC”
Unidades "LXXX"
1 2 3 4 5 6 7 8 9
Imprimir Imprimi Imprimi Imprimi Imprimir Imprimir Imprimir Imprimir Imprimir
"I" r "II" r r "IV" "V" "VI" "VII" "VIII" "IX”
"III"
Ejemplo 3.4.8:
Una Universidad Privada tiene una política de descuento en porcentajes
sobre el pago de pensiones de enseñanza, que se basa en la profesión del
tutor (policía, profesor de colegio, docente universitario, trabajador no
docente y otros) y, el rendimiento del alumno (bueno, regular, deficiente), tal
como se muestra en el cuadro siguiente:
Tabla de descuento (en.%)
Ocupacion \ Rendimiento A: bueno B: regular C: deficiente

P: policía 60 30 10
C: profesor de colegio 50 20 10
D: docente universitario 40 20 0
N; no docente 40: 10 0
0: otros 30 0 0
Lea la ocupación de un tutor y el rendimiento del alumno e indique cual es

su
Solución:
ocup: ocupación del tutor
rend: clasificación según rendimiento
Diagrama N/S
Leer, ocup, rend

ocup
‘P’ ‘C’ ‘D’ ‘N’ ‘O’

rend rend rend rend rend
‘A’ ‘B’ ‘C’ ‘A’ ‘B’ ‘C’ ‘A’ ‘B’ ‘C’ ‘A’ ‘B’ ‘C’ ‘A’ ‘B’ ‘C’
d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0. d=0.
6 3 l 5 2 l 4 2 0 4 1 0 3 0 0
Imprimir
d
Ejercicios Propuestos
Lea atentamente cada enunciadoy plantee una solución. Luego construya un
diagrama N/S y codifiquelo en Java.
1) Si las vocales se representan con números del 1 al 5, lea un número y

diga que vocal es.
2) Lea un número que represente el día de la semana y diga que día es,
teniendo en cuenta que la semana comienza en domingo.
3) Un alumno es calificado con a, b, c ó d. Será bueno si obtuvo un a,
regular si obtuvo un b, malo si obtuvo un c, y pésimo si obtuvo un d. Lea
un calificativo y escriba que tipo de alumno es.
4) Lea un número que represente el mes y diga que mes es.
5) Dada una fecha diga la fecha del día de ayer.
6) Escriba un programa que lea un número de canal de televisión y diga cual
es el nombre del canal.
7) Muestre las opciones de un menú, seleccione una opción e imprima
elmensaje apropiado indicando la opción seleccionada.
8) En una empresa comercial, existen 3 categorías de artículos (A, B y C) y
4 categorías de clientes (excelentes, buenos, regulares y malos) y tienen
implementada la siguiente política de descuentos (en %):
Tipo cliente\(ipo artículo A B C
E: Excelente 40 30 20
B: Bueno 30 20 10
R: Regular 20 10 0
M: Malo 0 0 0
Además se sabe que los clientes de tipo E y B pueden pagar en efectivo

con cheque o al crédito, los de tipo R solo pueden hacerlo en efectivo o
con cheque, mientras que los de tipo M sólo pueden hacer compras en
efectivo. Lea el tipo de cliente, el tipo de artículo que desea adquirír e
indique el descuento y las alternativas de pago que le son permitidas.
9) Dada una fecha ¿cuántos días faltan para que termine el año?
10) Obtenga el número de días transcurridos entre dos fechas.
11) Todo el mundo sabe cuántos años tiene, pero ¿podría contestar a la
pregunta cuántos días tiene?
12) Dada una fecha diga que día de la semana fue, sabiendo que el primero
de enero de 1900 fue lunes.
13) Dada una fecha obtenga el número de día dentro de ese año. Por
ejemploel 26/10/2000 es el día 300 del año 2000.
3.5. ESTRUCTURA REPETITIVA MIENTRAS
La estructura repetitiva mientras se caracteriza por realizar n iteraciones
mientras la pregunta condicional inicial se cumpla, en el caso que no se
cumple la condicion esta no realizra ninguna iteración.
Ejemplos:
Ejemplo 3.5.1:
Obtenga el cociente y el residuo de una división calculando la cantidad de
veces que un número está contenido en otro, mediante restas sucesiva:
Por ejemplo, si el dividendo es a = 5236 y el divisor b =1247, entonces
tendremos:
5236 - 1247 = 3989
3989 - 1247 = 2742
2742 - 1247 = 1495
1495 - 1247 = 248
Ya no seguimos restando pues 248 es menor que 1247. El cociente estará
dado por el número de restas (4) y el residuo por el último número obtenido
(248).
Solución: Diagrama N/S
a: dividendo b: divisor Leer a, b
El algoritmo hace la comparación "en coc = 0

lo alto", esto es antes de realizar
cualquier operación ya que si a es mientras ( a > b )
menor que b, entonces b no está
contenida ni una vez en a. a = a-b
En caso de que a sea mayor que b,
entonces se procederá a la resta. Cada coc = coc + 1
vez que esto ocurra el cociente
coc aumenta en una unidad. Imprimir coc, a
Finalmente el bucle termina cuando a
ya no sea mayor que b, debiendo imprimir el cociente coc y el residuo a.
Ejemplo 3.5.2:
La secuencia de Fibonacci es muy conocida en los circulos matemáticos y
tiene la particularidad que cada número es igual a la suma de 2 anteriores
términos. La serie de Fibonacci comienza con los números 0 y 1,
produciendo la siguiente secuencia: 0, 1, 1, 2, 3,5, 8, 13,.,., etc. Muestre
todo. Muestre todos los números de Fibonacci que un número dado.
Solución:
m: máximo número Fibonacci a mostrar

a : enésimo número Fibonacci
b : enésimo +1 número Fibonacci
Diagrama N/S
Leer m
a=0
b= 1
Imprimir a
mientras ( b < m)
Imprimir b
c=a+b
a=b
b=c
El algoritmo va calculando cada término de la secuencia como la suma del término

enésimo y el término enésimo + 1. Observe la necesidad de una tercera variable
a la que llamamos c, y sirve para no perder el valor de la suma cuando
cambiamos a y b.
Ejemplo 3.5.3:
Calcule los divisores comunes de dos números.Por ejemplo los divisores
comunes de 6 y 18 1,2,3 y 6.
Solución:
a: primer número
b: segundo número
i: posibles divisores
El algoritmo va generando los posibles divisores (i), desde la unidad y

mientras este sea menor que ambos números. Observe el uso del operador de
relación AND (en C++ es &&), pues es necesario considerar el caso de que
uno sea múltiplo del otro (por ejemplo 4 y 8).
El operador MOD obtiene el resto de la división entera entre sus argumentos

y por lo tanto si estas divisiones tienen como resto cero, i divide a los
números. En C++ el operador MOD se implementa haciendo que ambos
argumentos sean de alguno de los tipos enteros (int, long int, unsigned int,
etc.) y operándolos con %.
Diagrama N/S
Leer a, b
i= 1
mientras ( i<= a AND i<=b )
a MOD i == 0 AND
b MOD i==0
V F
Imprimir i
i=i+1
Ejemplo 3.5.4:
Factorizar un número ingresado por teclado. Por ejemplo 8 = 2 x 2 x2.
Solución:
n: número cuyos factores se desean obtener

i: posibles factores
No debemos confundir el término factorizar que significa encontrar todos los

factores primos de un número y el término factorial que significa el producto
de todos los números consecutivos desde la unidad hasta el mismo número.
Para encontrar todos los factores de un número necesitamos generar los

posibles valores que puedan dividir a dicho número. Esto se logra con la
variable i que inicializamos en 2, no se considera el 1 porque es un factor de
todos los números. El bucle se ejecuta mientras estos posibles factores
i sean menores que el número n. Si i divide exactamente a n entonces le
sacamos el factor i mediante la división entera n = n / i, y lo imprimimos. En
este caso i no aumenta en una unidad, pues deberá volver a probar si i es
nuevamente un factor de n. El incremento de i ocurre solamente cuando i no
dividió a n ejecutándose la parte correspondiente al else.
Diagrama N/S
Leer n
i=2
mientras (i< =n )
n MOD i == 0
V F
n = n/ i
Imprimir i i = i+ l
Ejemplo 3.5.5:
Escriba un algoritmo que diga si un númeroes primo.
Solución:
n: número a evaluar
i: posible divisor
band: 0 indica que no es primo
Un número es primo, cuando solamente es divisible por la unidad y por sí

mismo. Entonces, necesitamos encontrar un número i mayor que 1 pero
menor a n, que divida exactamente a n, para afirmar que n no es primo. Si
esta búsqueda no es satisfactoria el número será primo.
Suponemos pues, que todo número es primo, hasta que se demuestre lo
contrario; así que usaremos un indicador bandera (flag) representado por la
variable band. Si band = 1 el número es primo y no lo es cuando band = 0.
Comenzamos inicializando los posibles divisores i, igual a n/2, pues no
existen divisores que sean mayores que la mitad del número, para ir
preguntando si i divide a n, en este caso debemos cambiar band a cero,
indicando que el número n ha sido dividido por otro número i diferente de 1 y
de e1 mismo, y por lo tanto n ya no será primo. Al terminar el bucle,
Preguntamos por band si fuera igual a 1, el n será primo y no primo en caso
contrario.
Diagrama N/S
Leer n
i=n/2
band =1
mientras (i >1 )
n MOD i == 0
V F
band = 0 i=i-l
band = =1
V F
Imprimir Imprimir
"Es primo” "No es primo"
Ejemplo 3.5.6:
Escriba un programa que permita reducir una fracción a su mínima
expresión. Por ejemplo: 28/64 = 7/16.
Solución:
a : numerador
b: denominador
i: posible divisor de a y b
Basta con probar si i divide al numerador y al denominador al mismo tiempo, para

cada i desde 2 y mientras sea menor a ambos números. Si í es un divisor de a y
b, entonces simplificar la fracción en caso contrario probar con el siguiente i.
Diagrama N/S
Leer a, b
i=2
mientras ( i< =a AND i<=b)
a MOD i == 0 AND
b MOD i= = 0
V F
a=a/i
i = i+ l
b=b/i
Imprimir
a, “∕”, b
Ejemplo 3.5.7:
Lea un número y forme otro número con las cifras en orden inverso. Así si el
número es 12345 el nuevo número será 54321.
Solución:
n: numero cuyos dígitos se invertirán

inv: número invertido
Para obtener un nuevo número inv, formado por los dígitos de n, pero en
orden invertido, debemos obtener cada uno de los dígitos de n, e ir
desplazándolos un valor posicional (unidad, decena, centena, etc.). Cada uno
de los dígitos, pueden ser obtenidos al buscar el resto de la división entera
entre 10 (n MOD 10) y se debe ir incrementando el valor posicional
mediante la multiplicación del resto por 10, y su acumulación en la variable
inv. Se puede usar la división entera (que de manera estándar se representa
mediante el operador DIV, y que en C++, se implementa con el operador /)
siempre y cuando sus argumentos sean de tipo entero. El ciclo se ejecuta
mientras el número aún tenga dígitos que obtener (mientras n sea mayor
que cero), luego del cual imprimimos inv.
Diagrama N/S
Leer n
inv = 0
mientras ( n >0 )
inv = 10*inv + n MOD 10

n = n DIV 10
Imprimir
inv
Ejemplo 3.5.8:
Un número se considera perfecto cuando la suma de sus divisores es igual al
número. Por ejemplo 6 tiene como divisores a 1, 2 y 3 y como 1+2+3= 6, el
número 6 será perfecto; 28 tiene como divisores a 1,2, 4, 7, 14, luego 28 es
perfecto pues 1+2+ 4+7+14=28, lo mismo ocurre con 496 y 8128. Escriba
un programa que lea un número y diga si es perfecto
Solución;
n: numero a evaluar
s: suma de los divisores
Basta con obtener sus divisores y sumarlos. Utilizaremos la siguiente

estrategia, comenzando desde la mitad del número n iremos probando los
posibles divisores i, disminuyendo i de uno en uno, mientras i sea mayor que
cero.
En caso de que n sea dividido exactamente por i acumular i en s, y probar

siguiente i. Al final del bucle preguntamos si la suma s, resultó ser igual al
número digitado n, en cuyo caso imprimiremos que n es perfecto.
Diagrama N/S
Leer n
s=0
i=n/2
mientras (i >0 )
n MOD i == 0
V F
s=s+1
i=i-l
s = =1
V F
Imprimir Imprimir
"Es perfecto" "No es perfecto"
Ejemplo 3.5.9:
Los números Amstrong o cubos perfectos, son aquellos que sumados a los
cubos de sus dígitos nos dan el mismo número. Por ejemplo 153 es un cubo
perfecto pues 13 + 53 + 33 = 153. Lea un número y diga si es o no, un cubo
perfecto.
Solución:
n: número a evaluar
se: suma de los cubos de sus cifras
temp: se iguala inicialmente a n, y sirve para trabajar en el algoritmo sin
perder n
De manera similar al ejercicio anterior pero esta vez obtenemos cada dígito
para elevarlo al cubo y acumularlo en sc. Si se resulta ser igual a n, entonces
el número es un cubo perfecto.
Pruebe el algoritmo con los siguientes cubos perfectos: 1, 153, 370, 371 y
407.
Diagrama N/S
Leer n
sc = 0
temp = n
mientras (temp >0 )
sc = sc + (temp MOD 10)3
temp = temp DIV 10
n = = sc
V F
Imprimir Imprimir
"Cubo "No es cubo perfecto”
perfecto"
Ejemplo 3.5.10:
Lea un número y una base de un sistema de nuemeración, y diga si el número
pertenece a ese sistema de numeración, teniendo en cuenta que para que un
número pertenesca a un sistema de numeración todos su digitos deben ser
menores que la base.
Solución:
El sistema de numeración que normalmente utilizamos, debido a su sencillez,

es el sistema decimal cuya base es 10. Sin embargo, cualquier número mayor
de 1, puede ser la base de un sistema de numeración. De hecho son
importantes en computación los sistemas de numeración en base 2, 8 y 16.
Para decir que un número puede pertenecer a un sistema de numeración, se

tendrá que verificar que cada uno de sus dígitos sea menor que la base. Por
ejemplo en base 2 sólo son válidos los dígitos 0 y 1, en base 3 los dígitos 0, 1
y 2, ... , en base 10 los dígitos 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9; mientras que en
sistemas de numeración con bases mayores a 10 se utilizan las letras del
alfabeto, por ejemplo en base 16 son válidos los dígitos 0, 1,2, 3, 4, 5, 6, 7, 8,
9, A, B, C, D y F. Esto restringirá nuestro algoritmo, hasta comprender como
usar los caracteres y es por ello que nuestro programa solamente funcionará
cuando la base sea menor a 10.
base: base del sistema numérico

num: número ingresado en base base
band: bandera. 1 indica que número no es correcto en esa base
Entonces, dado el número num y la base base, debemos encontrar cada dígito
de num. Si alguno de estos dígitos es mayor que base, entonces debemos
indicar que dicho número no es correcto activando la bandera haciendo band
=1 y, cuando terminemos de evaluar todos sus dígitos, preguntar si esa
bandera fue puesta a 1, en cuyo caso no será un número válido en dicho
sistema de numeración.
Diagrama N/S
Leer base, num

band = 0
mientras ( num > 0 )
num MOD 10 >=base
V F
band = 1
num = num DIV 10
band == 1
V F
Imprimir Imprimir
"No es de esa base" "Es de esa base"
Ejemplo 3.5.11:
Lea un número entero en la base 10, yconviertalo a otra base menor que 10.
Solución:
Se sabe que para convertir un número en base 10 (Sistema Decimal) a otra

base, debemos dividir sucesivamente el número entre la base, hasta encontrar
un cociente menor que dicha base (en algoritmos por computadora nos
conviene seguir la división hasta que el cociente sea cero). El número en la
nueva base estará formado por todos los residuos pero en orden inverso a como
se fueron obteniendo.
Por ejemplo sea el número 194 en base 10, al que deseamos convertir a base 5,
entonces:
194 5
(4) 38 5
(3) 7 5
(2) 1 5
(1) 0
194(10) = 1234 (5)
Los residuos escritos en el orden en que fueron obtenidos son: 4, 3,

2 y 1. Pero, el número equivalente a 194 en base 5 es 1234. Nótese la
necesidad de formar el número desde el último residuo hasta el primero.
La restricción que la base sea menor que 10, no afecta a este

algoritmo en su desarrollo manual. Sin embargo, en su implementación
mediante computadoras debemos manejar adecuadamente los caracteres
para bases mayores que 10, lo cual no es considerado en esta parte, por
tratarse de un libro introductorio al mundo de la programación y aún no
trataremos sobre manipulación de caracteres.
n: número en base 10, además es utilizado como el número en la nueva
base
base: base a la cual se quiere convertir n
inv: variable de trabajo que almacena los sucesivos residuos
obtenidos al realizar la conversión.
Nuestro algoritmo se basa en realizar divisiones sucesivas obteniendo el

residuo mediante n MOD base, y el cociente entero mediante n DIV base, e
irá formando el número a partir de los residuos. Sin embargo, el número
encontrado en realidad es el número pedido pero en orden inverso, por lo
tanto, se hace necesario escribir una pequeña rutina que invierta dicho
número para tener el número deseado (ver ejemplo 4.7).
Diagrama N/S
Leer n, base
inv = 0
mientras ( n > 0 )
inv = 10*inv + n MOD base
n = n DIV base
mientras (inv > 0 )
n= 10*n+ inv MOD 10
inv = inv Dív 10
Imprimir n
Ejemplo 3.5.12:
Lea un número entero en una base menor que 10, y conviertalo a base 10.
Solución:
Para convertir un número escrito en una base distinta a 10, debemos obtener sus
dígitos y multiplicarlos por la base de numeración en que se encuentran pero
elevada a la potencia según su valor posicional disminuido en una unidad. Por
ejemplo, para convertir el número 1234(5) a su equivalente en base 10, haremos lo
siguiente:
4(5)° + 3(5)1 + 2(5)2 + 1(5)3 = 194(10)
n: número en base base

base: base del número ingresado
nuevo: número en base 10
i: indica el exponente al que elevaremos base
Diagrama N/S
Leer n, base
i=0
nuevo = 0
mientras ( n > 0)
nuevo= nuevo + (n MOD 10)
(base1)
n = n DIV 10
i = i+1
Imprimir
nuevo
Nuestro algoritmo leerá el número n y la base base en la que está escrita,

obteniendo sucesivamente cada uno de sus dígitos, multiplicándolos por la
potencia de la base adecuada, mientras que el número tenga dígitos (sea mayor a
cero).
Ejemplo 3.5.13:
El máximo común divisor (mcd) de un conjunto de números es el máximo
número que divide exactamente a todos ellos. Encuentre el mcd de dos
númerospor el método de Euclides.
Solución:
Euclides ideó un algoritmo para encontrar el mcd, de dos números y consiste
en dividir sucesivamente ambos números hasta que el divisor sea cero.
Suponga que se desea obtener el mcd de los números 2363 y 2057,

procederemos tal como se muestra:
1 6 1 2 1 1 2
236 205
306 221 85 51 34 17
3 7
306 221 85 51 34 17 0
Observe que en la parte superior aparecen los cocientes de las divisiones y en

la parte inferior los restos, los cuales pasan a formar el nuevo divisor
mientras el resto sea mayor que cero. El mcd, será el último divisor, esto es
17.
a : primer número (dividendo)
b: segundo número (divisor)
r: resto de la división entera
Diagrama N/S
Leer a, b
mientras (b>0)
r = a MOD b
a=b
b=r
Imprimir a
Ejemplo 3.5.14:
Encuentre el mcd de dos numeros por restas sucesivas
Solución:
a: primer número
b: segundo número
Una forma alternativa de realizar una división es mediante restas tal como se
vio en el Problema 3.5.1. Así, el Algoritmo de Euclides, pero aplicando restas
sucesivas en vez de la división, puede implementarse tal como se observa en el
diagrama N/S.
Diagrama N/S
Leer a, b
mientras ( a≠b)
a>b
V F
a=a-b b=b-a
Imprimir a
Ejemplo 3.5.15
Obtenga el máximo común divisor mcd de dos números
por descomposición de factores. Tomemos los números 360 200 2
360 y 200 y procedemos a probar sucesivamente si los 180 100 2
números i = 2, 3, … dividen a ambos.Cuando la división 90 50 2
de 360 y 200 entre i sea exacta, realizamos las divisiones 45 25 5
y volvemos a probar con el mismo i. 0 5
En caso deque i no divida a ambos números probamos con el siguiente i, y

asi sucesivamente, mientras i sea menor que ambos números.
Finalmente el mcd, estará formado por el producto de todos los divisores

encontrados en este caso mcd = 2x2x2x5 = 40. Escriba un algoritmo que
encuentre el mcd de 2 números mediante este método.
Solución:
a: primer número
b: segundo número
mcd: máximo común divisor
Diagrama N/S
Leer a, b
mcd = 1
i =2
mientras ( i<= a AND i<=b )
a MOD i == 0 AND
b MOD i==0
V F
a =a/ i
b =b/i i = i+ 1
mcd = mcd * i
Imprimir
mcd
Ejemplo 3.5.16;
E1 mínimo común múltiplo (mcm) de 2 o más números, es el menor número
contiene a todos ellos una cantidad exacta de veces. Construya un algoritmo
para calcular el mcm de 2 números leídos por teclado.
Solución:
a: primer número
b: segundo número
mcm: mínimo común múltiplo
band: 0 indica si i aumentará en 1
Diagrama N/S
Leer a, b
mcm =1 i=2 band = 0
mientras ( i<= a OR i<=b )
a MOD i = = 0 OR
b MOD i = = 0
V F
mcm = mcm*i
a MOD i = = 0
V F
a = a/ i i=i+1
b MOD i = = 0
V F
b =b/í
Imprimir
mcd
Ilustremos el algoritmo mediante un ejemplo. Tomemos los números 360 y

200, e intentemos encontrar su mcm, por descomposición de sus factores
primos, tal como se muestra.
360 200 2
180 100 2
90 50 2
45 25 3
15 25 3
5 25 5
1 5 5
1 1
De donde el mcm será:

2x2x2x3x3x5x5 = 1800
A diferencia del mcd, basta que uno de los números sea dividido por i, para
entrar en el cálculo del mcm. De aquí el uso de OR en vez del AND.
Lea atentamente cada enunciado y plantee su solución. Luego construya su
diagrama N-S coreespondiente.
1) El factorial de un número se define como el producto de todos los

números consecutivos desde la unidad hasta el número y se denota
por el símbolo !. Por ejemplo 4! - 4x3x2x1, teniendo en cuenta esto,
lea un número y encuentre su factorial.
2) Encuentre el mcm de dos números ayb sabiendo que (a)(b) = (mcm)
(mcd).
3) Para simplificar una fracción, basta con dividir su
numerador y denominador entre el mcd de ambos. Implemente un
algoritmo que simplifique una fracción haciendo uso de esta idea.
4) Determine cuántos dígitos tiene un número entero ingresado por
teclado.
5) ¿Cuántos dígitos impares tiene un entero ingresado por teclado?
6) Lea un entero y diga cuál es su dígito mayor.
7) Dos números se consideran amigos si la suma de los divisores de uno
es igual al otro número. Por ejemplo 220 y 284 son amigos. Lea dos
números y diga si son amigos entre sí.
8) Se sabe que n2 = 1 +3 +5 +7 + 2n-l. Se pide leer un número y calcular
su cuadrado haciendo uso de esta relación.
9) Un número es capicúa o palíndromo, si el número es tal que
invirtiendo sus cifras da el mismo número. Así 12321 es capicúa
porque invirtiendo sus cifras nos da 12321. Escriba un algoritmo que
diga si un número ingresado es capicúa.
10) Calcule la enésima potencia entera de un número teniendo en cuenta
que el exponente puede ser negativo. Considere el caso que cualquier
número elevado a la potencia cero da la unidad.
11) El mínimo común múltiplo (mcm) de 2 o más cantidades es el menor
número que los contiene una cantidad exacta de veces. Construya un
algoritmo para calcular el mcm de 3 números.
12) El máximo común divisor (mcd) de un conjunto de números es el
máximo número que divide exactamente a todos ellos. Construya un
algoritmo para calcular el mcd de 3 números.
13) Construya un algoritmo que adivine el número entero pensado por
usted en la menor cantidad de intentos posibles.
3.6. ESTRUCTURA REPETITIVA HACER MIENTRAS

La estructura secuencial se caracteriza por mostrar problemas con
caracteristicas secuenciales donde por ningún caso se hara uso de alguna
otra estructura. Los problemas plantados mayormente tienen ambito
matematico ó aritmetico cumpliendo los tre requisitos basicos de un
diagarama: Entrada, Proceso y Salida.
Ejemplos:
Ejemplo 3.6.1:
Encuentre el valor de π sabiendo que la suma de la serie: 1- 1/3 + 1/5 –
1/7+1/9 + ….es igual a π/4. Sugerencia: considere los términos cuyo valor
absoluto sea mayor a 0.000001.
Solución:
Diagrama N/S
i =1
Definición de variables: pi4 = 0
i: denominador varia de 2 en 2
signo = -1
pi4: cuarta parte de pi
hacer
signo: variable contiene el signo del término
signo = -signo
pi4 = pi4 + signo*(l/i)
i=i+2
En la serie mostrada el denominador aumenta mientras ( 1/i >
en 2 para cada término, y los signos se alternan 0.000001)
entre positivo y negativo. Imprimir
"Pi vale:", 4*pi4
Para este cálculo bastará con un bucle dentro del cual se haga el cambio de
signo, acumule el término y aumente en 2 el denominador (i), mientras el
valor absoluto del término actual (1/i) sea mayor a 0.000001.
Como la suma de todos los términos es π/4, debemos con multiplicar a pi4
por 4, para obtener π.
Ejemplo 3.6.2:
Hallar la raíz cuadrada de un número por el método de Newton.
Solución:
área: área del cuadrado
ladoO: lado inicial supuesto
ladol: lado calculado
Diagrama N/S
Leer área, lado0

hacer
lado 1 = area/lado0
lado0 = (lado0+ladol)/2
mientras fabs(ladol-
lado0)>0.00001
Imprimir
"lado:", lado0
Usaremos la siguiente analogía. Considere un cuadrado de lados lado0 y lado1

y de área área. Si se conoce el valor de área (el número cuya raíz se desea) y
se tiene un valor inicial estimado del lado (lado0) y como lado0.1adol=area,
entonces. ladol=area/lado0, dado que lado0 y ladol deben ser iguales (por
tratarse de un cuadrado), debemos ir aproximándolos a un único valor.
Una buena aproximación del lado0 es tomar la media aritmética entre los dos
valores obtenidos (lado0 y ladol) y asignarlo al nuevo lado0, tal expresión
sería: lado0 = (lado0 + ladol ) / 2, luego hay que volver a calcular el nuevo
ladol como ladol = área / lado0, y así sucesivamente hasta que la diferencia
entre lado0 y ladol sea despreciable.
Ejemplo 3.6.3:
Lea una serie de numeros hasta engresar el valor de cero.Luego indique
cuantos números positivos, negativos, pares e impares fueron ingresados.
Solución:
Diagrama N/S
imp: cantidad de números impares i = imp = neg = 0

neg: cantidad de números negativos
Hacer
i: cantidad números ingresados
Leer n
n: número i ingresado
i = i+l
Usaremos los contadores i, imp y neg n MOD 2 = = 1
los cuales deberán ser inicializados a V F
cero. imp = imp + 1
n<0
Dentro del bucle leemos el número (n) V F
a evaluar y aumentamos la cuenta del neg = neg + 1
total de números leídos (i). Si n no es mientras ( n ≠ 0 )
dividido entre 2, aumentaremos la i=i-l
cuenta de los impares Imprimir "Total de números:", i
"Pares : ", i - impar
(imp=imp+l). Si n es menor que cero "Impares : " , impar
aumentaremos la cuenta de los "Positivos : " , i - neg
negativos (neg=neg+l). En caso de "Negativos: " , neg
haber ingresado un valor diferente de
cero la condición (n # 0) es verdadera y por lo tanto el bucle hacer...mientras,
seguirá ejecutándose.
En caso de que n sea igual a cero, imprimiremos la cantidad de pares, impares,

positivos y negativos.
Ejemplo 3.6.4:
Se tiene una lámina rectangular de largo y ancho conocidos a la que se
recorta un cuadrado de lado x en cada esquina con el objeto de formar una
caja. ¿Cuáles son las dimensiones de esta caja, si se desea que el volumen
sea el máximo posible?
Solución:
largo: largo de la lámina
ancho: ancho de la lámina
x: longitud del lado del cuadrado recortado
xmax: longitud del lado que hace máximo el volumen
vol: volumen de la caja
volmax: volumen máximo de la caja
Se trata de un problema de optimización (más concretamente de maximización),

que puede resolverse mediante el cálculo diferencial o también, mediante el
cálculo de diversos valores para el volumen para tomar el mayor.
En muchos casos el aplicar cálculo diferencial, es muy difícil o sumamente
laborioso. Se puede demostrar que el máximo volumen de la caja se obtiene
cuando:
x= ((ancho + largo)· sqrt( ancho2 – ancho.largo + largo2) ∕ 6
Sin embargo, aquí postraremos otro método. Según el enunciado del

problema debe omplirse que 0 < x ≤ ancho/2, por lo |Hbastará calcular los
volúmenes dentro de este rango y guardar el nayor de ellos.
Así, leemos el largo y ancho la lámina, inicializamos la longitud lado

recortado (x) y el volumen máximo (volmax), a cero (cuando tratamos de
obtener un máximo, el valor inicial de comparación debe ser el mínimo
posible).
Diagrama N/S
Dentro del bucle vamos Leer largo, ancho

aculando los volúmenes de todas
x = volmax = 0
las x, con diferencias de 0.0001 entre
cada x y realizando la comparación Hacer
para que voturnen es mayor y el valor x = x + 0.000l
de x para el cual dicho volumen es vol = (largo - 2x) (ancho - 2x) x
Máximo (xmax). vol > volmax
V F
volmax = vol
xmax = x
mientras (x< ancho/2 - 0.0001)
Imprimir
"Volumen máximo:", volmax
"Largo : " , largo - 2xmax
"Ancho : " , ancho-2xmax "Altura
: " , xmax
Ejemplo 3.6.5:
¿Cual es la máxima área de terreno que se pueda obtener si las longitudes de un
terreno son x y (20-x)?
Solución:
Definición de variables: Diagrama N/S
inc: incremento inc = 0.0001

x: una de las dimensiones del terreno x=0
xmax: valor que hace máxima el área areamax = 0
área: área del terreno Hacer
areamax: el área máxima del terreno x = x + inc
area = x (20 - x)
area > areamax
V F
areamax = area
xmax = x
mientras (x <= 20 - inc)
Imprimir
"Área máxima:", areamax
"Dimensiones:", xmax, 20 - xmax
Como el área tiene que ser positiva, entonces debe cumplirse que 0 < x ≤ 20,
por lo que calculamos las áreas para todos los x desde 0 hasta 20 con
incrementos pequeños (0.0001) y obteniendo la mayor área, y el valor de x
que hace máxima el área (xmax).
Lee atentamente cada enunciado y plantee su solución. Luego construya un
diagrama N-S.
1) En una universidad se pueden llevar hasta 22 créditos en un ciclo.

Escriba un algoritmo que permita a un alumno matricularse, sin
pasarse del límite de créditos permitido.
2) Una vendedora de pan tiene n unidades de pan al comenzar el día.
Si cada cliente le pide m panes, ¿Cuántos clientes son atendidos
completamente? ¿Cuántos panes quedan para el último cliente?
3) Un cliente de un banco realiza sucesivos retiros desde un cajero, si
posee 1000 al inicio de las operaciones, escriba un programa que le
permita retirar dinero mientras tenga fondos.
4) En un cajero se muestra un menú de opciones retiro, saldo,
depósito y salir. Escriba un algoritmo que efectúe dichas
operaciones.
5) A una fiesta ingresan personas de diferentes edades, no se permite
elingreso de menores de edad. Se pide la edad menor, la mayor, y
el promedio de edades. El ingreso debe terminar cuando la edad
ingresada sea cero
6) Calcule la suma de 1/x, si x varía desde 1 hasta 2 con incrementos
muy pequeños, por ejemplo 0.0001, luego multiplique la
suma por el mncremento y demuestre que el resultado se aproxima
a ln 2 = 0.6931...
7) Lea un número positivo y pártalo en 2 sumandos de forma que su
producto tenga un valor máximo.
8) ¿Qué rectángulo con perímetro igual a 50 tiene área máxima?
9) Una ventana tiene forma de rectángulo culminado por un
semicírculo. El perímetro de la ventana es 6m. ¿Cuáles son sus
dimensiones si debe dejar pasar el máximo de luz?
10) La función seno(x) va en aumento a partir del punto x=0..
Encuentre el valor positivo de x para el cual la función comienza a
disminuir. Respuesta: π/2.
11) Unaa ecuación de la parábola es y = ax*x + bx +c. Si a>0 la
parábola está dirigida hacia arriba y tiene un máximo, si a< O la
parábola está dirigida hacia abajo y tiene un mínimo. Lea a, b y c y
determine el máximo o el mínimo según corresponda. Considere
x≥0.
3.7. ESTRUCTURA REPETITIVA PARA
La estructura repetitiva para se caracteriza por realizar multiples
iteraciones consecutivas, basandose en un valor inicial, condicion final e
incremento ó decremento según sea el problema planteado.
Ejemplos:
Ejemplo 3.7.1:
Calcule la suma de la siguiente serie.
Solución:
t: término cualquiera
s: acumulador indica la suma de términos
n: número de términos
i:indica el término actual
Diagrama N/S
t=l
s=l
Leer n, x
i = l; i<=n; i = 1 +l
t= t * x / i
s=s+t
Imprimir
s
Se observa que la razón entre un término y el anterior es x/i, luego si tenemos

el primer término los otros términos se obtendrán multiplicando el término
anterior por la razón x/i, e ir acumulándose en s, hasta el enésimo término.
Puede demostrarse que si x =1, y n es lo suficientemente grande, la suma se

aproxima a la base de los logaritmos neperianos e (e =2.718281...)
Ejemplo 3.7.2:
Un vehículo recorre n distancias en n tiempos diferentes ¿cual será la
velocidad promedio para toda la trayectoria?
Solución:
n: cantidad de trayectos
i: indica el trayecto i
d: distancia recorrida en trayecto i
t: tiempo utilizado en trayecto i
dt: distancia total recorrida
tt: tiempo total utilizado
Diagrama N/S
Leer n
dt = tt = 0
i = 1; i<= n; i = i + 1
Leer d, t
dt = dt + d
tt = tt + t
Imprimir dt/tt
La velocidad de un móvil se obtiene dividiendo la distancia recorrida entre el

tiempo utilizado. En este caso se pide la velocidad promedio para todo el
trayecto, dicha velocidad estará dada por la distancia total recorrida entre el
tiempo total utilizado. Entonces bastará con acumular las distancias que se
van recorriendo (d) y los tiempos (t), que se utilizaron, para al final obtener
la relación dt/tt.
Ejemplo 3.7.3:
Encuentre el valor numérico de un polinomio de grado n.
Solución:
i: indica el exponente de x
n: grado del polinomio
coef: coeficiente de xi
valor: valor numérico del polinomio
Diagrama N/S
valor = 0
Leer n, x
i = n; i >= 0; i = i - 1
leer coef
valor = valor * x + coef
Imprimir
valor
Sea el polinomio f(x) = anxn + an-1xn-1+ an-2xn-2 + ... + a2x2 + a1x1 + a0x0
El coeficiente an será multiplicado por x, n veces; an-1 será multiplicado por x,

n-l veces; an-2 será multiplicado por x, n-2 veces; y así sucesivamente hasta
a0, que no será multiplicada por x. Esto es aprovechado por nuestro
algoritmo para leer cada coeficiente y multiplicarlo por x, leer el otro
coeficiente y multiplicar el acumulado (valor) por x, de esta manera el
primer coeficiente resulta multiplicado por xn, el segundo por xn-1 el tercero
por xn'2, y así sucesivamente hasta que el término independiente no es
multiplicado por ningún x.
Ejemplo 3.7.4:
Encuentre el promedio de n números.
Solución:
s: acumulador indica la suma de los n números

i: contador, indica el número actual a ser leído
n: número de datos a leer
nro: actual número leído
Diagrama N/S
s =0
Leer n
i =1; i<=n; i = i +
1
Leer nro
s = s + nro
Imprimir
s/n
Debemos ingresar la cantidad de números que vamos a leer, e ir
acumulándolos en la variable s (previamente inicial izada en 0), conforme se
vayan leyendo. Al término de la lectura de los n números debemos obtener el
promedio dividiendo la suma (s) entre el total de números leídos (n).
Ejemplo 3.7.5:
Encuentre el promedio ponderado de n números.
Solución:
sn: acumulador, indica la suma de los números leídos

sp: acumulador, indica la suma de los pesos o ponderaciones leídos
i: contador, indica el número actual leído
n: número de datos a leer
nro: actual número leído
p: peso o ponderación de nro
El promedio ponderado se utiliza para calcular el promedio de un conjunto de

datos, cuando dichos datos tienen ponderaciones o pesos diferentes.
Matemáticamente:
Diagrama N/S
sn = 0
sp = 0
Leer n
i =1; i<=n; i = i + 1
Leer nro, p
sn = sn + nro*p
sp = sp + p
Imprimir
sn/sp
ASÍ pues, necesitamos leer cada uno de los n números con sus respectivos
pesos y calcular la sumatoria de todo los nro*p. Asimismo, debemos calcular
la sumatoria de todos los p.
Finalmente solo nos queda dividir las sumas encontradas.
Ejemplo 3.7.6:
Muestre las tablas de multiplicar del 1 al 15.
Solución:
i: indica Ja tabla de multiplicar

j: indica cada número de la tabla del i
Este algoritmo muestra como podemos anidar los bucles. Para ello se requiere de
un bucle externo (i), que indique la tabla de multiplicar que estamos obteniendo;
y de un bucle interno (j) que indique cada línea de la tabla de multiplicar i, tal
como se muestra.
Diagrama N/S
i =1; i<=15; i = i+l

Imprimir
"Tabla de multiplicar", i
j =1; j<=15; j=j + l
Imprimir
i, "x", j, " - ", i*j
Ejemplo 3.7.7:
Simule un "reloj rápido”que muestre en pantalla, las horas minutos y
segundos.
Solución:
hor: horas
min: minutos
seg: segundos
Diagrama N/S
hor = 0; hor <24; hor = hor + 1

min =0; min<60; min = min + 1
seg = 0; seg < 60; seg=seg + l
Imprimir
hor, min, seg
Este es otro ejemplo de como podemos anidar el bucle for. Las horas
solamente pueden tomar valores desde 0 hasta 23. Los minutos desde 0
hasta 59, los segundos desde 0 hasta 59. De estos 3 bucles, quien debe
cambiar más rápido es el bucle de los segundos, por lo tanto será el bucle
más interno, luego vendrían los minutos y finalmente las horas. Recuerde que
quien cambia más despacio es el bucle más externo. Por lo demás el
algoritmo no requiere mayor explicación.
Ejemplo 3.7.8:
¿Cuántos números de 4 cifras existen, tales que sean múltiplos de 3 y 7?
Solución:
i: números a evaluar
m : Cantidad de números de 4 cifras múltiplos de 3
y 7.
Debemos evaluar todos los números de 4 cifras (entre 1000 y 9999),

preguntando si son divididos por 3 y por 7 al mismo tiempo. Para esto
hacemos uso de un bucle en el cual se irá generando sucesivamente los
números a evaluar, dentro del cuerpo del bucle se procede a la evaluación y si
la condición es cierta aumentaremos el contador m en una unidad. Finalmente
imprimiremos m.
Diagrama N/S
m=0
i = 1000; i<=9999; i =i+l
i MOD 3== 0 AND
i MOD 7== 0
V F
m = m +1
Imprimir m
Ejemplo 3.7.9:
Los números enteros que satisfacen la ecuación a2 + b2 = c2, se les conoce
como ternas pitagóricas. Encuentre todas las ternas pitagóricas menores que
n.
Solución:
a: posible número pitagórico

b: posible número pitagórico
c: posible número pitagórico
Diagrama N/S
Leer n
a=l; a<=n; a = a+ 1
b=l; b<=n; b = b+l
c= 1; c<=n; c = c + 1
a2 + b2 = =c2
V F
Imprimir
a, b, c
Este ejemplo es muy ilustrativo de cómo podemos anidar la cantidad de

bucles deseados.
Debemos leer n, luego mediante 3 bucles generar los posibles valores de a, b

y c que sean menores o iguales que n y que cumplan la condición a2 + b2 =
c2, en cuyo caso tendremos una terna pitagórica y debemos imprimirla.
Ejemplo 3.7.10:
Cuatro artículos cuestan 3, 7, 19 y23 soles respectivamente ¿Cuáles son las
posibles cantidades que podemos adquirir de cada artículo, si disponemos de
113 soles y deseamos gastarlo todo?
Solución:
a: posible cantidad de artículos comprados de 3 soles

b: posible cantidad de artículos comprados de 7 soles
c: posible cantidad de artículos comprados de 19 soles
d: posible cantidad de artículos comprados de 23 soles
Diagrama N/S
a=0; a<=(113 DIV 3); a = a+l
b=0; b<=(113DIV7); b = b+l
c=0; C<=(113 DIV 19); c=c+1
d=0; d<=(113 DIV 23); d=d+l
3a + 7b + 19c +23d = = 113
V F
Imprimir
a, b, c, d
Debemos generar a, b, c y d con valores desde 0 artículos comprados, hasta

la máxima posible cantidad de artículos para cada uno (113 DIV 3, 113 DIV 7
113 DIV 19 y 113 DIV 23 respectivamente).
Para esto hacemos uso de 4 bucles, uno para cada tipo de artículo. En el bucle
más interno preguntamos si la cantidad gastada es igual a 113 soles, en cuyo
caso imprimimos a, b, c y d.
Ejemplo 3.7.11:
Lea n números e indique cual es el mayor.
n: cantidad de números
i: sirve para llevar la cuenta de números
may: número mayor
nro: número leído
Para encontrar el mayor de un conjunto de números debemos compararlos de

dos en dos para obtener el mayor de ambos y luego tomar otro número y
seguir comparando hasta que no tengamos más números que comparar.
Sin embargo, tenemos una dificultad, el primer número tomado no tiene con
quien compararse, por lo tanto necesitamos asumir un valor para realizar la
primera comparación. Podemos inicializar may a un valor tan pequeño, para
que la primera vez que se compare siempre deba asignarse a may el primer
número leído, este es el procedimiento aplicado. En compiladores de 16 Bits
de C++ -32767 es el mínimo valor de tipo entero que podemos tener, y esta
es la razón que Inicializamos may a este valor. Otra forma es asumir que el
primer número leído es mayor y luego proceder a comparar los números
restantes.
Diagrama N/S
may = -32767
Leer n
i = 1; i<= n; i = i
+1
Leer nro
nro > may
V F
may = nro
Imprimir
may
Ejemplo 3.7.12
Muestre todos los números de 3 digitos tales que si invertimos sus cifras el
número original aumente en 297.
Solución:
i: es el número a evaluar
nro: es el número a invertir
inv: es el número invertido
Diagrama N/S
i =100; i<1000; i = i+l

nro = i
inv = 0
mientras ( nro > 0 )
inv = 10*inv + nro MOD 10
nro = nro DIV 10
i + 297 = = inv
V F
Imprimir
i
Debemos generar todos los números i, de 4 cifras e ir probando uno a uno.

Para esta prueba se debe invertir el número tal como se hizo en el ejemplo
4.7, y luego preguntar si el número original i aumentado en 297 es igual al
número invertido inv.
Ejemplo 3.7.13:
Obtenga el producto de n fracciones. De el resultado como una fracción
simplificada.
Solución:
i: contador indica la fracción i.

Utilizado también como generador de posibles divisores durante la
simplificación de la fracción
n: numerador de la fracción i
d: denominador de la fracción i
pn: producto de numeradores
pd: producto de denominadores
nro: cantidad de fracciones
Diagrama N/S
Leer nro
El algoritmo va obteniendo el producto pn = pd = 1
de las fracciones conforme se las va
ingresando. i = 1; i<= nro; i=i+l
Leer n, d
Una vez ingresados y multiplicados
todos los numeradores y pn = pn * n
denominadores, se procede a la pd = pd * d
simplificación de la fracción, tal como
se hizo en el Problema 4.6. i=2
mientras (i<=pn AND i<=pd )
pn MOD 1 ==0 AND
pd MOD i ==0
V F
pn = pn /i
i = I +1
pd = pd /i
Imprimir pn,"/", pd
Ejemplo 3.7.14:
Suma n fracciones. De el resultado com una fracción simplificada.
i: contador indica la fracción i.

Utilizado también como generador de posibles divisores durante la
simplificación de la fracción
n: numerador de la fracción i
d: denominador de la fracción i
nr: numerador resultante dr: denominador resultante
nro: cantidad de fracciones
Diagrama N/S
Leer nro
i = 1; i<= nro; i=i+l
Leer n, d
i ==1
V F
nr = n nr = d*nr + n*dr
dr =d dr = d*dr
i=2
mientras (i<=nr AND i<=dr)
nr MOD i == 0 AND
dt MOD i ==0
V F
nr = nr / i i = i +1
dr = dr / i
El algoritmo implementado consiste en ir sumando las fracciones conforme
se vayan leyendo, de tal manera que siempre tendremos 2 fracciones que
sumar: la resultante y la que acabamos de ingresar. La suma de dos fracciones
tales como nr/dr y n/d de manera general es: (d*nr+ n*dr)/(d*dr) expresión
que es utilizada por nuestro algoritmo, dentro del bucle for.
Finalmente, simplificamos la fracción nr/dr.
Ejemplo 3.7.15:
¿De cuántas maneras se pueden ordenar n objetos?
Solución:
i: indica el i-ésimo objeto

n: número de objetos
fact: cantidad posible de ordenamientos
Diagrama N/S
fact = l
Leer n
i = 1; i<=n; i = i +1
fact = fact * i
Imprimir fact
El primer objeto puede ubicarse en cualquiera de las n posiciones, el segundo

objeto en cualquiera de las n-1 restantes, el tercero en cualquiera de las n-2
restantes,..., el enésimo-1 objeto se podrá ubicar en cualquiera de las 2
ubicaciones restantes, y finalmente el enésimo objeto se ubicará en última
posición.
Luego, el valor pedido será: n ( n - l ) ( n - 2 ) . . . ( 2 ) ( l ) .
A la cantidad posible de formas de ubicar n objetos se le conoce como

permutaciones y como las permutaciones de n objetos equivalen al producto
de los números consecutivos desde la unidad hasta el número, intonces las
permutaciones pueden obtenerse calculando el factorial de n.
Matemáticamente: Pn = n!
Luego basta leer n y calcular su Factorial.

Ejemplo 3.7.16:
¿De cuantas maneras podemos colocar n objetos en r lugares diferentes?
(n≥r)
Solución:
v: cantidad posible de ordenamientos
Diagrama N/S
v=l
Leer n, r
i = 1; i<=r; i = i +1
v = v * ( n - i + 1)
Imprimir
v
El problema no es otro que el cálculo de variaciones de n objetos tomados de

r en r. Las variaciones se definen como la cantidad posible de formas que
podemos tomar r objetos de un total de n objetos en donde la posición es
importante. Decir ab es diferente que decir ba, a pesar de que ambos tengan
los mismos objetos (a y b), son diferentes por el orden que ocupan.
Razonando: el primer lugar puede ocuparse de n maneras, el segundo lugar
de n-1 maneras, el tercer lugar de n-2 maneras, ..., el r-ésimo lugar puede
ocuparse de (n-r+1) maneras. Como solamente disponemos de r lugares,
tendremos el producto de r términos consecutivos.
Matemáticamente podemos escribir:

Vnr = n (n -1) (n - 2) (n - 3) ... (n - r+1) o también:
Esta última fórmula es usada en cálculos manuales, sin embargo en

computadoras, usaremos la primera forma, por ser más eficiente. El algoritmo
es sencillo basta leer n y obtener el producto de r términos cada uno
disminuido en una unidad (una estrategia alternativa es hacer disminuir n
multiplicando los términos mientras que i sea igual a n-r+1).
Ejemplo 3.7.17:
¿De cuantas maneras podemos tomar r elementos de un total de n
elementos? (n≥r)
Solución:

r: número de objetos por grupo
c: número de combinacionesDiagrama N/S
c=l
Leer n, r
i=l; i<=r; i = i+l
c = c * ( n - i + l)/i
Imprimir
c
El enunciado del problema no es otro que el cálculo de combinaciones de n
objetos tomados en grupos de r elementos. Las combinaciones se definen
como la cantidad de formas que podemos tomar r objetos de un total de n
objetos en donde la posición no es importante, aquí, decir ab es igual a decir
ba, pues son los mismos objetos. Sea Cnr el número de combinaciones
requerido, cada una He estas combinaciones consta de r objetos deferentes
los cuales pueden ordenarse entre si de r! maneras, por lo tanto Cnr .r! es
igual a Vnr
De donde:
Puede demostrarse que la relación que existe entre Cnr y Cnr-i, viene dada por:
Relación que utilizaremos para lacer más fácil la inplementación del

algoritmo; y además porque el factorial de un número crece rápidamente que
si calculamos cada uno de los 3 factoriales, fácilmente rebasamos el rango
permitido.
Ejemplo 3.7.18:
Los coeficientes que se obtienen al desarrollar el Binomio de Newton para
exponentes enteros pueden calcularse en base al coeficiente anterior mediante
relación coef = coef*(i-j+l)/j, donde coef, es el coeficiente del término
actúal; i es el exponente del binomio y, j indica que término se está
calculando. Escribe un programa para mostrar los coeficientes en forma de
triángulo. A este triángulo se le conoce como Triángulo de Pascal o
Tartaglia.
1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
Solución:
n: cantidad de filas del triángulo o exponente del binomio + 1
i: fila actual
j: columna actual
coef: coeficiente binomial
El Binomio de Newton (a+b)n tiene una forma conocida de desarrollo que nos
evita tener que multiplicar n veces (a+b). Dicho desarrollo esta dado por:
De donde se puede observar que los coeficientes de cada uno de los términos,
son jrecisamente las combinaciones de n elementos tomados de r en r, esto es:
Cnr = n! / [r!. (n- r)! ], y por lo tanto la relación siguiente también se cumple.
Esta expresión ha sido indicada en el enunciado del problema, mediante la

expresión coef =coef*(¡-j+l)/j. La similitud que existe entre el calcular
simplemente el número combinatorio y los coeficientes del desarrollo del
binomio (a+b)n es que cada uno de los coeficientes es el número
combinatorio.
Por lo tanto es un algoritmo similar al ejercicio anterior pero esta vez se

incluirá un bucle (el bucle i) que indica cuántos números combinatorios
(número de términos del desarrollo del binomio) deseamos encontrar.
Diagrama N/S
nro = 1
Leer n
Imprimir nro
i = 1; i<=n; i = i +1
Imprimir nro
j = l; j<=i; j=j+l
nro = nro* (i-j + l)/j
Imprimir nro
Ejercicios propuestos

diagrama N/S.
1. Muestre todos los pares entre a y b , y diga cuántos son.

2. Un número se considera perfecto si es igual a la suma de sus divisores
menores que el. Escriba un programa para encontrar todos los números
perfectos dentro de un rango dado.
3. Encuentre todos los números primos de 3 dígitos.
4. Un cubo perfecto o número Amstrong es aquel que sumados los cubos
de sus dígitos nos dan el mismo número. Encuentre los 5 únicos cubos
perfectos.
5. Dos números son amigos cuando la suma de los divisores de uno de
ellos es igual al otro y viceversa. Muestre, si existen, los números amigos
donde ambos números sean menores que n.
6. Muestre todos los números capicúas o palíndromos dentro de un rango
determinado Un número es capicúa cuando al invertir sus cifras nos da
el mismo número.
7. Leern números e indique el mayor, menor y el promedio.
8. Lea n notas con sus respectivos pesos y obtenga el promedio ponderado.
9. Construya la tabla de sumar del 1 al 20.
10. Imprima el número 1, una vez; el 2, dos veces; el 3, tres veces; y así
sucesivamente hasta llegar a un número n ingresado por teclado
11. Si tenemos n dígitos y deseamos formar números de r cifras (n≥r),
¿Cuántos números diferentes podemos obtener?
12. Escriba un programa que muestre los n primeros números de la
secuencia de Fibonacci. Demuestre que la razón entre dos términos
consecutivos se aproxima a (1 + )/2, este número es conocido como
"el justo medio".
13. Un vendedor hace n ventas. Por cada venta de hasta S/. 1000, recibe el
10% de comisión, por ventas de hasta S/. 3000 recibe 8% sobre el monto
adicional a 1000, mientras que si llega a S/. 5000 recibirá el 6% sobre
el adicional a 3000, por ventas de hasta S/. 9000 recibirá el 4% sobre el
adicional a 5000, finalmente recibirá el 2% por toda venta superior a S/.
9000. ¿Cuál es el total de sus ventas y cuánto recibe de comisión por
ellas?
14. Dada una fecha dd/mm/aaaa, imprima el calendario correspondiente a
ese mes.
15. Escriba un programa que genere todos los números de 4 dígitos en base
6 y sus equivalentes en base 10.
16. Determinar la suma de los n primeros términos de la serie:
X/1 - X2/22 + X3/32 - X4I42 +X5/22 ...
3.8. ARREGLOS UNIDIMENCIONALES
Los arreglos unidimensionales se caracterizan por permitir trabajar con
memoria, es decir se podra ingresar tantos valores y estos no se perderan
mientras el programa se este ejecutando.
Ejemplos:
Ejemplo 3.8.1:
Lea n números almacénelos en un array e imprímalos.
Solución:
Diagrama N/S
n: número de elementos del array Leer n
i: subíndice del término actual
x[ ]: array unidimensional i = 0; i<n; i = i+l
Leer x[ i ]
Un array es un conjunto de i = 0; i<n; i = i+l
datos referenciados con el mismo
nombre, pero distinguidos mediante Imprimir x[i]
un subíndice, y en donde cada
elemento es del mismo tipo. Cada uno de los elementos del array se
referencia con el nombre del array (x) seguido y de un subíndice ( i ). En
JAVA, los subíndices van desde 0, hasta [el límite declarado para el array
menos uno.
En nuestra particular implementación definimos un array de 50

elementos cada uno de tipo flotante con subíndices válidos desde 0 hasta 49,
en este caso n puede asumir como máximo el valor de 50.
Para poder leer cada uno de los elementos del array (x[i]),
necesitamos conocer cuántos datos vamos a leer (n) y luego hacer un bucle
para leer cada l uno de ellos haciendo variar el subíndice (i) desde cero hasta
n-1. Una vez ingresados los elementos solo debemos imprimirlos mediante
otro bucle.
Ejemplo 3.8.2:
Calcule la media aritmética de un cojunto de datos.
Solución:
n: número de elementos del array
s: suma de los elementos
x[ ]: array unidimensional
Diagrama N/S
Leer n
i = 0; i<n; i = i +1
Leer x[i ]
s=0
i = 0; i<n; i = i+l
s = s + x[i]
Imprimir s/n
Primero leemos cuántos elementos vamos a ingresar (n) y mediante

un bucle los leemos haciendo variar el subíndice (i).
La media aritmética de un conjunto de datos se obtiene mediante la fórmula:
El numerador de esta expresión se calcula en el último bucle

utilizando el acumulador (s) previamente inicializado en cero. El
denominador es un dato ingresado (n).
Como ambos valores numerador (s) y denominador (n) son conocidos

solo nos resta calcular s/n e imprimir el resultado.
Ejemplo 3.8.3:
Calcule la media armónica de un conjunto de datos.
Solución:

s: suma de los elementos
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer x[ i]
s=0
i = 0; i<n; i =i+l
s = s+ l/x[i]
Imprimir n/s
La media armónica se efine como "El inverso del promedio de los inversos".
Matemáticamente:
Entonces, bastará con calcular la sumatoria de los inversos de los elementos

(∑ B/x[i]), pues n es conocido. Este cálculo lo hacemos en el ultimo bucle,
por lo que al término de este solo nos resta calcular l/s/n o lo que es lo mismo
n/s e imprimirlo.
Ejemplo 3.8.4:
Calcule la media geométrica de un conjunto de datos.
Solución:
i: subíndice del dato actual
p: producto de los datos
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer x[i ]
p=1
i = 0; i<n; i = i+1
p = p *x [i ]
Imprimir p1/n
La media geométrica se define como la raíz enésima del producto de todos los
datos.
Matemáticamente:
Luego solo debemos calcular el producto de todos los elementos y obtener su

raíz enésima, tal como se muestra.
Ejemplo 3.8.5:
Calcule el promedio ponderado de un conjunto de datos
Solución:
valores[ ]: conjunto de elementos
pesos[ ]: ponderaciones de los valores[i]
sv: suma de los valores[i]
sp: suma de los pesos[i]
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer valores [i], pesosfi]
sv = 0
sp = 0
i = 0; i<n; i = i+l
sv = sv +valores[i] *
pesos[i]
sp = sp + pesos [i]
Imprimir sv/sp
El promedio ponderado se usa cuando tenemos datos que tiene diferentes

ponderaciones o pesos.
Matemáticamente:
Luego necesitamos calcular la sumatoria de los productos de valores[i] por
pesos[i], y la sumatoria de pesos[i]. Esto se efectúa en el último bucle.
Finalmente, nos queda dividir lichas sumatorias e imprimir el Resultado.

Ejemplo 3.8.6:
Diga si un elemento sse encuentra en un array, utilice la busqueda secuencial.
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer x[ i ]
Leer elem
band = 0
i = 0; i<n; i = i+l
x[i] = elem
V F
Imprimir i
band = 1
band==0
V F
Imprimir
"No lo encontré"
Solución;
elem: elemento a buscar
Una vez ingresados los n elementos en el array, leemos el valor que

deseamos buscar (elem) y recorremos secuencialmente todos los elementos
(uno después del otro) comparando elem con cada elemento (x[i] == elem),
en caso de ser iguales se mostrará el mensaje adecuado y se colocará la
bandera band a 1, (la cual fue puesta inicialmente a 0) indicando que el
elemento ha sido encontrado.
Al terminar el bucle, preguntamos por la bandera band. Si ésta aún

continúa en 0, significará que el elemento no ha sido encontrado.
Ejemplo 3.8.7:
Elimine los elementos repetidos de un array.
Bolución:
j: subíndice del resto de términos desde i hasta n
k: subíndice de los términos desplazados
lista[ ]: array unidimensional
Debemos leer el número de elementos (n) e ingresarlos en el array. Luego

necesitamos tomar cada elemento y compararlo con los restantes en caso pe
ser uno igual al otro hay que eliminar el elemento repetido, copiando todos
los elementos siguientes a una ubicación anterior a su posición actual y,
pisminuyendo el número de elementos en uno (n= n-1).
El primer bucle se mcarga de la lectura de los n elementos del

array. En los bucles [anidados (bucles i y j), el bucle más externo (el
bucle i), se encargará de tomar cada elemento lista[i], para ser
comparado con el resto. Los elementos con los que lista[i] va a ser
comparado, serán todos los elementos desde una posición siguiente:
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer lista[ i ]
i = 0; i < n; i=i+1
j = i + l; j<n; j=j+l
lista[i] = lista[j]
V F
k=j;k<n-l;k=k+l
lista[k]=lista[k+l]
n = n- 1
j =i
Imprimir n
i = 0; i<n; i = i+1
Imprimir lista[ i ]
(lista[i+l]) hasta el final de la lista. Esto se consigue en el bucle más interno (el
bucle j), donde j va desde i+1 hasta n-1. En este último bucle se realizan las
comparaciones entre lista[i] y Iista[j], si son iguales hay que copiar todos los
elementos siguientes a una posición anterior. De esto se encarga el bucle k, que va
ha empezar a desplazar la lista desde j hasta el elemento final. Al salir del bucle
es necesario disminuir n en 1 y hacer j = i, para volver a probar si el término que
buscamos se encuentra nuevamente repetido, al hacer j = i y volverse a ejecutar
el bucle j, éste automáticamente sumará 1 a j, ocasionando que se vuelva a ejecutar
el bucle j como si fuera la primera vez. Finalmente, imprimimos el número actual
de elementos (n) y cada uno de ellos (Iista[i]).
Ejemplo 3.8.8:
Calcule la varianza y desviación estándar de un conjunto de datos

almacenados en un array.
Solución;
La varianza y la desviación estándar son medidas de la dispersión de

los datos con respecto a la media. Si los datos son muy cercanos a la media, el
valor de la varianza y la desviación estándar es pequeño; sin embargo, si los
datos están muy dispersos ambas medidas serán grandes.
Matemáticamente:
Donde: x: es la media aritmética de los elementos.

x[i]: es el elemento i-ésimo.
n: es la cantidad de elementos.
De las fórmulas anteriores se observa que la desviación estándar es la raíz

cuadrada de la varianza.
Diagrama N/S
Leer n
i = 0; i<n; i = i +1
Leer x[ i ]
s=0
i = 0; i<n; i = i+l
s = s + x[i]
media = s/n
i = 0; i<n; i = i+l
suma = suma + (x[i] -
media)2
Imprimir suma/n, (suma/n)1/2

x[ ]: array unidimensional s: suma de los n elementos
media: media aritmética del array
suma: suma de los cuadrados de las diferencias de cada elemento respecto a
la media
Luego de leer n y los elementos del array, calculamos la media

aritmética, para lo cual inicializamos s en 0, y acumulamos todos los
elementos del array para obtener la media mediante la operación media=s/n.
Seguidamente, calculamos la sumatoria de los cuadrados de las

desviaciones de cada elemento respecto a la media (∑ (x[i] - media )2 ) y
calculamos la varianza dividiendo esta sumatoria entre n. El cálculo de la
desviación estándar es simple, pues basta con saber que es la raíz cuadrada de
la varianza.
Ejemplo 3.8.9:
Ajuste los pares de puntos (x,y) almacenados arrays x[ ], y [ ] a la recta
y = ax + b, por el método de regresión lineal.
Solución:
Este método consiste en tomar pares de puntos (x, y) que guardan

Ilguna relación, y encontrar la ecuación de la recta que más se ajuste a
nuestros atos, con el objeto de realizar un pronóstico del tipo "si tenemos un
x cuánto aldráy, teniendo en cuenta la serie de valores históricos".
Se puede demostrar que dado los arrays x[] y y[ ] podemos

ajustados a a recta y = ax + b, donde:
n: número de elementos
x[ ]: valores independientes
y[ ]: valores dependientes
sx: sumatoria de los x[i]
sy: sumatoria de los y[i]
sxx: sumatoria de los x[i]*x[i]
sxy: sumatoria de los x[i]*y[i]
a: coeficiente de x
b: término independiente de x
Comenzamos leyendo la fantidad de elementos (n), e igresamos los datos

en los arrays
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer x [i]
i = 0; i<n; i = i+l
Leer y [i]
sx = 0
sy = 0
sxx = 0
sxy = 0
i = 0; i<n; i = i+l
sx = sx + x[i]
sy = sy + y[i]
sxx = sxx + x[i]*x[i]
sxy = sxy + *[i]*y[i]
a = ( n*sxy - sx*sy ) / ( n*sxx - sx* sx )
b = (sy*sxx - sx*sxy)/ ( n*sxx - sx* sx )
Imprimir
a, b
Si x[ ] y y[ ] en sus respectivos bucles. Posteriormente, en el último bucle

calculamos las sumatorias requeridas. Para esto hacemos uso de Jos
acumuladores sx, sy, sxx y sxy que previamente han sido inicializados a 0.
Finalmente, imprimimos la recta de regresión.
Ejemplo 3.8.10:
Ordene un conjunto de datos de menor a mayor por el método de la burbuja
array.

i: inicialmente indica los elementos del array que no están ordenados
j: indica los elementos que se van a comparar e intercambiar
temporal: utilizada para el intercambio
El método de ordenamiento conocido como "método de la burbuja",

consiste en tomar el último elemento y compararlo con el anterior y de ser
necesario realizar el intercambio para que el elemento menor siempre que de
delante; luego, se toma el penúltimo elemento y se compara con el anterior y
de ser necesario se realiza el intercambio; y así sucesivamente, hasta que el
menor elemento de todo el array se encuentre en la primera posición. Como
el elemento menor ya esta en su sitio, éste debe obviarse en los siguientes
pasos, y por lo tanto se repite todo el proceso pero sin considerar los
elementos que van fcuedando en su sitio.
Esto es implementado en nuestro Diagrama N/S. En primer lugar debemos

leer los n elementos en el array x [i].
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer x[ i ]
i = 1; i < n; i=i+1
j = n - 1; j >=i; j = j -1
x[j-l] > x[j]
V F
temporal = x[j-l]
x[i-l] = x[j]
x[j] = temporal
Imprimir n
i = 0; i<n; i = i+1
Imprimir x[i]
En los bucles anidados, el bucle más interno (el bucle j) recorre todos
los elementos del array desde la última posición (n-1) hasta la última
ubicación prdenada (i). En la primera iteración irá comparando cada elemento
con el anterior desde n-1 hasta i=l.
Al llegar al elemento con subíndice j=l (j>=i) se hace la

comparación x[0]>x[l], con lo cual aseguramos que fueron comparados todos
los elementos, y que el elemento menor de todos ellos se encuentra en x[0].
Luego i se incrementa en 1, para que en el bucle j, el elemento x[0] al estar
ordenado ya no sea tomado en cuenta.
Posteriormente, se recorren los elementos sin ordenar desde la última

posición (n-1) hasta la última posición no ordenada i, comparándolos e
intercambiándolos hasta finalizar el bucle i, esto es hasta que todos los
elementos estén ordenados (hasta que la última posición no ordenada sea la
n-1). Finalmente, imprimimos el array correctamente ordenado.
Ejemplo 3.8.11:
Ordene un conjunto de datos de menor a mayor por el método de de selección.
Solución:

j: subíndice para comparar los elementos sin ordenar
k: subíndice del elemento menor
temporal: valor del elemento menor y es utilizada para el intercambio
El "método de selección", consiste en seleccionar el menor

elemento del array y colocarlo en la primera ubicación mediante el
intercambio de valores. Entre los elementos restantes nuevamente buscamos
el menor y lo colocamos en la segunda ubicación, mediante el intercambio de
valores; y así sucesivamente, hasta tener todos los elementos ordenados.
Diagrama N/S
Leer n
i = 0; i<n; i = i+l
Leer x[ i ]
i = 0; i<n-1: i = i+l
k=i
temporal = x[i]
j=i+l; j<n; j=j + l
x[j] < temporal
V F
k=j
temporal = x[j]
x[k] = x[i]
x[i] = temporal
i = 0; i<n; i = i + 1
Imprimir x[i]
Una vez leídos los elementos y entrando al algoritmo de ordenamiento en sí,
la primera vez que se ejecuta el bucle i se hace la asignación k=0 y
temporal=x[0], aquí se está suponiendo que el menor elemento es el primero
y corresponde al subíndice 0 (esto es parte del algoritmo de buscar el menor
elemento de un array). Luego se inicia el bucle j, y sirve para encontrar el
menor elemento de todos, tomando como valor inicial de comparación al
primer elemento.
Al término del bucle j, k contiene el subíndice del menor elemento y

temporal contiene el valor del menor elemento, los cuales serán
intercambiados a la primera ubicación no ordenada mediante la secuencia
x[k] = x[i] seguida por x[i]=temporal. Estos pasos se repiten hasta tener
todos los elementos ordenados, que corresponde a las comparaciones para el
elemento n-2, pues solo podrá compararse con el elemento n-1. (i<n-l).
Finalmente solo nos resta imprimir el array ordenado.
Ejemplo 3.8.12:
Ordene un conjunto de datos de mayor a menorpor el método de la inserción.
Solución:

i: indica cuantos elementos faltan ordenar j: sirve para comparar y
desplazar los elementos
temporal: valor del elemento que será insertado.
El "método de inserción" consiste en tomar el segundo elemento e

insertarlo junto al primero en la posición que corresponda, luego tomar el
tercer elemento e insertarlo entre los dos elementos en la posición
adecuada, continuamos con el cuarto elemento y lo insertamos entre los tres
en la posición adecuada; y así sucesivamente, hasta tomar el último elemento.
Tomemos el primer elemento x[0], luego los elementos restantes que
queramos insertar serán desde i=l hasta i=n-l, que corresponden al bucle más
externo (bucle i) de los bucles anidados. Posteriormente, asignamos el
elemento que deseamos insertar a la variable temporal y buscamos la
posición correcta donde se insertará.
Esto último se hace en el bucle j. Así, se recorre todos los elementos ya
ordenados desde la posición más alta y mientras el subíndice sea válido
(j>=0) y el valor que deseamos insertar (temporal), sea menor que el
elemento x[j]. Esto hace que realmente se ubique en la posición correcta.
DiagramaN/S
Leer n
i = 0; i<n; i = i+l
Leer x[ i ]
i = l; i<n; i = i +1
temporal = x[i]
j=i-l; j>=0 AND temporal <x[ j]; j=j-l
x[j+l]=x[j]
x[j+1] = temporal
i = 0; i<n; i = i + 1
Imprimir x[i]
En cada iteración del bucle j, se desplaza el elemento comparado x[j]

hacia la posición x[j+l] para hacerle sitio al elemento a insertar (temporal).
Al término del bucle j, se habrá encontrado la posición adecuada para insertar
temporal y por lo tanto se realiza la asignación x[j+l] = temporal. Esta
secuencia se vuelve a repetir hasta que se hallan insertado los n-1 elementos
restantes (recuerde que se tomo el primero), en la posición correcta de
ordenamiento.
Ejemplo 3.8.13:
Dado un número del día de un determinado año, encuentre el día, mes y año
al que corresponde, sabiendo que: enero, marzo,mayo, julio, octubre y
diciembre tienen 31 días; abril, junio, setiembre y noviembre tienen 30 días,
y que febrero tiene 28 y 29 días según sea un año normal o un año bisiesto.
Por ejemplo, el día número 300 del año 2000 es el 26/10/2000.
Solución:
i: indica el mes (0... 11)
annio: guarda el año
nrodia: número de día leído
dias[ ]: array. Almacena número de días de los meses
suma: acumulador. Indica número de días hasta esa fecha
Comenzamos inicializando los días que tiene cada mes en el array dias[ ].
Aquí hacemos la suposición que se trata de un año normal (dias[l]= 28) y en
caso no ser cierto se procederá a su cambio (dias[l]= 29). Para esto
mecesitamos recordar la condición de bisiesto (ver Problema 2.8):
(annio MOD 4 == 0) AND (annio MOD 100 != 0) OR (annio MOD 400 =

0)
Diagrama N/S
dias[ ] = { 31,28,31,3031,3031,31,3031,30,31}
Leer nrodia, annio
( annio MOD 4==0)AND( (annio MOD 100*0)
OR (annio MOD 400==0))
V F
días[l]=29
suma = 0
i=0
Mientras ( nrodia > suma )
suma = suma + dias[i]
i = i+l
suma = suma - dias[i-l]
Imprimir (nrodia - suma), " /" , i, " /", annio
En caso de que la anterior expresión sea cierta febrero tendrá 29 días

debiendo realizarse la asignación dias[l] = 29.
Debemos averiguar primero hasta que mes transcurrió (i) para el número de
días ingresados (nrodia).
Esto se consigue acumulando todos los días de cada mes (suma), mientras el
número de días (nrodia) sea mayor que los días acumulados (nrodia>suma).
Como al término del bucle mientras, se acumuló los días de un mes de más,
es necesario restar esos días de suma, esto se consigue mediante suma =
suma -días[í-l], el subíndice resulta ser i-1, puesto que al término del bucle
mientras se incremento i en 1.
Luego, la fecha está compuesta por los días transcurridos del mes actual que
son nrodia-suma, el mes es i (puesto que se le aumento 1 antes de salir del
bucle), y el año es annio.
Ejercicios propuestos:
diagrama N/S.
1) Encuentre el mayor y el menor elemento de un array.

2) Lea dos arrays A y B y diga que elementos de A no están en B.
3) Lea un array e invierta las posiciones de sus datos. Por ejemplo, si el
array es a[ ] = {1, 2, 3} al término del algoritmo debe ser a[ ] = {3, 2,
1}.
4) Se tienen dos arrays ordenados y se desea unirlos en un tercero pero
manteniendo los datos ordenados.
5) Suponga que tiene n elementos en un array ordenado ascendentemente.
Inserte un elemento en la posición que corresponda para mantener el
array ordenado.
6) Determine la cantidad de veces que aparece cada elemento de un array.
7) La moda de un conjunto de datos es el elemento que más se repite.
Encuentre la moda de elementos almacenados en un array.
8) Si tenemos un array ordenado. Encuentre un determinado elemento
utilizando la búsqueda binaria.
9) Calcule la mediana de un conjunto de datos. La mediana en un array
ordenado es el elemento central. Si el número de elementos del array es
impar existe un único elemento ubicado en el centro del array (el
elemento con subíndice n DIV 2 + 1). Si el número de elementos del
array es par, existen dos elementos centrales (elementos con subíndices
n DIV 2 y n DIV 2 +1), la mediana estará dada por el promedio de
ambos.
10) Lea dos arrays x[ ] y y ( ] calcule su recta de regresión y determine cuál
será el valor de y conociendo el valor de x.
11) Se tiene un vector de n dimensiones. Si dicho vector se representa
mediante un array la longitud del vector estará dada por
. Lea un vector y calcule su longitud.
12) Sean dos vectores x e y el producto escalar se define como
es la magnitud del vector y es el ángulo que
forman. Sin embargo, si se conocen sus coordenadas rectangulares en el
espacio Rn el producto escalar se reduce a la siguiente expresión:
. Lea las coordenadas de los vectores en el espacio Rn,
almacénelos en un array y calcule su producto escalar.
CAPITULO IV
INTRODUCCIÓN A JAVA

Este capitulo le introduce al estudiante a conocer el fundamento y
estructura del lenguaje de programación Java para la resolución de
algoritmos.
4.2. ¿QUE ES JAVA?

Hacia 1990, James Gosling, quien trabaja para Sun Microsystems, fue el
encargado de crear programas para controlar aparatos electrónicos
domésticos. Originalmente Gosling y su equipo empezaron el diseño de
su software usando C++, debido a su orientación a objetos. Sin embargo,
se dieron cuenta que C++ no satisfacía los proyectos que se tenían en
mente; encontraron dificultades con aspectos complicados de C++ como
la herencia múltiple de clases, errores de programación (bugs)
relacionados con huecos de memoria. De esta manera Gosling decidió
que tenía que empezar por escribir un lenguaje simplificado que le
evitara todos los problemas que se encontró con C++.
Aunque a Gosling no le importó la complejidad de lenguajes como
C++, tomo la sintaxis básica y la orientación a objetos del lenguaje.
Cuando terminó el nuevo lenguaje lo llamó Oak (se cuenta que el
nombre le vino a Gosling mientras veía un roble por la ventana de su
oficina.)
Oak se uso por primera vez en un proyecto llamado Proyecto Green,

donde el equipo de desarrollo intentó diseñar un sistema de control
para usar dentro del hogar. Este sistema de control permitiría al
usuario manipular distintos dispositivos, como televisiones, video
caseteras, luces caseras y teléfonos, todo desde una computadora de
mano llamada *7 (Star Seven). El sistema *7 incluía una pantalla
sensible para que el dueño seleccionara y controlara estos dispositivos.
La pantalla del *7 tenía diversas figuras, entre las que se encontraba

Duke (la actual mascota de Java). Duke ha sido incluido en muchos
ejemplos de applets en la página de Sun Microsystems.
El siguiente paso para Oak fue el proyecto Video En Demanda (VOD),

en el que el lenguaje era usado como la base para el software que
controlaría un sistema de televisión interactivo. Aunque ni *7 ni el
proyecto VOD concluyeron en productos actuales, le dieron a Oak una
oportunidad de crecer y madurar. Con el tiempo Sun Microsystems
descubrió que el nombre Oak ya había sido usado y le cambió el
nombre por Java, y vio nacer un lenguaje poderoso y sencillo.
Java es un lenguaje independiente de la plataforma, lo que significa que

los programas desarrollados en Java correrán en cualquier sistema sin
cambios. Esta independencia de plataforma se logró usando un
formato especial para los programas compilados en Java. Este
formato de archivo, llamado "byte-code" puede ser leído y ejecutado
por cualquier computadora que tenga un intérprete de Java. Este
intérprete de Java, por supuesto, debe ser escrito especialmente para el
sistema en el que correrá.
En 1993, después de que Internet se transformó de un ambiente

basado en texto a un ambiente gráfico, el equipo de Java se dio cuenta
de que el lenguaje sería perfecto para la programación en el Web. Así
nació la idea de los applets, que son pequeños programas que pueden
ser incluidos en páginas de Web, y también surgió la idea de escribir
un navegador de Web que demostraría el poder del lenguaje, este
navegador es el HotJava.
Finalmente, hacia mayo de 1995, Sun Microsystems anunció

oficialmente a Java. El nuevo lenguaje fue aceptado como una
poderosa herramienta para el desarrollo de aplicaciones para
Internet. Netscape Communications, e l creador del navegador
Netscape Navigator, dio soporte a Java desde su versión 2.0. Otros
desarrolladores de software también incluyeron soporte para Java,
incluyendo al Internet Explorer 3 de Microsoft. Actualmente, Java puede
correr en máquinas con procesadores SPARC, Intel, Digital.
De acuerdo con Sun Microsystems, Java es "simple, orientado a objetos,

tipificado e s t á t i c a m e n t e , compilado, independiente de arquitectura,
multi-procesos, con recolector de basura, robusto, seguro y ampliable."
Es simple porque los desarrolladores en Java deliberadamente

dejan muchas de las características innecesarias de otros lenguajes
de programación de alto nivel. Por ejemplo, Java no soporta
aritmética de apuntadores, cast de tipos implícito, estructuras o
uniones, sobrecarga de operadores, plantillas, archivos de cabecera o
múltiple herencia.
Es orientado a objetos, porque como C++, Java usa clases para organizar
el código en módulos. En tiempo de ejecución, un programa crea
objetos a partir de las clases. Las clases en Java pueden heredar de otras
clases, pero la múltiple herencia, donde una clase hereda métodos y
datos de varias clases, no está permitida.
Es tipificado estáticamente porque todos los objetos usados en un

programa deben ser declarados antes de que puedan ser usados. Esto
permite al compilador de Java localizar y reportar conflictos con los
tipos de datos.
Es compilado porque antes de que se pueda correr un programa,

primero tiene que ser compilado por el compilador de Java. El
resultado de la compilación es el archivo "byte-code", que, similar a un
archivo con código máquina, puede ser ejecutado bajo cualquier
sistema operativo que tenga un intérprete de Java. Este intérprete lee el
archivo byte-code y traduce los comandos en comandos de lenguaje
máquina que pueden ser ejecutados directamente por la computadora.
Es multiprocesos porque los programas de Java pueden contener

múltiples procesos en ejecución, lo que permite a los programas
manejar varias tareas simultáneamente. Por ejemplo, un programa
multiprocesos puede definir una imagen (render) en un proceso
mientras continua aceptando entrada del teclado en el proceso
principal. Todas las aplicaciones tienen al menos un proceso
(llamado thread) que representa la ejecución del programa.
Tiene recolector de basura, ya que los programas de Java no se

encargan de liberar de memoria los objetos, esto es una tarea del
administrador de memoria y el recolector de basura.
Es robusto porque el intérprete de Java revisa todos los accesos al

sistema dentro de un programa, por esto, los programas desarrollados
en Java no pueden tirar el sistema. Esto es, cuando un error serio es
encontrado, los programas en Java crean una excepción. Esta excepción
puede ser capturada y manejada por el programa sin el riesgo de
bloquear el sistema.
Es seguro porque el compilador no sólo verifica todos los accesos a

memoria, sino que también se asegura que no entren virus en un applet
en ejecución. Ya que los apuntadores no son soportados por el lenguaje,
los programas no pueden acceder a áreas del sistema a las que no tienen
autorización.
Es ampliable porque los programas en Java soportan métodos nativos,
que son funciones escrit as en ot ros lenguajes, general ment e
C ++. Est e soport e a métodos nativos permite a los programadores
escribir funciones que pueden ser ejecutadas más rápido que las
funciones equivalentes escritas en Java. Los métodos nativos son
ligados a los programas en forma dinámica, es decir, son asociados
con los programas en tiempo de ejecución.
Ventajas de Java.
Es seguro.
Se aprende con facilidad.
Es orientado a objetos.
No bloquea el sistema.
Aplicaciones para comunicación en red.

No tiene aritmética de apuntadores.
Es independiente de la plataforma.
Soportado por Microsoft.
Caracteristicas de Java
Java tiene las siguientes características:

• La Máquina Virtual de Java (JVM)
• Recolección de basura
• Seguridad en el código
La especificación de la Máquina Virtual de Java define a ésta como:

"Una máquina imaginaria que es implantada por la emulación de
software en una máquina real. El código para la JVM es almacenado
en archivos .class, cada uno contiene código para al menos una clase
pública". Esta especificación permite a los programas Java ser
independientes de la plataforma porque la compilación es hecha por
una máquina genérica. Al intérprete de Java de cada plataforma de
hardware le corresponde asegurar la ejecución del código compilado
para la JVM.
Muchos lenguajes de programación permiten el alojamiento dinámico

de memoria en tiempo de ejecución. Este proceso varía en la sintaxis
de los lenguajes, pero siempre hay un valor de retorno de un apuntador
a la dirección de inicio d e l bloque de memoria. Una vez que la
memoria ocupada ya no se necesita, el programa o el ambiente de
ejecución debería liberar la memoria para prevenir que el programa
corra sin memoria disponible.
En C y C++ (y otros lenguajes), el programador es responsable de

liberar la memoria. Esto puede ser tedioso, porque no se sabe con
anticipación cuando se va a l i b e r a r memoria. Los programas que no
liberan memoria pueden bloquear el sistema cuando no queda memoria
disponible. Java quita esa responsabilidad de liberar memoria
explícitamente integrando un proceso a nivel de sistema que sigue cada
alojamiento de memoria y mantiene una cuenta del número de
referencias a cada apuntador a memoria. Durante los intervalos de
tiempo de ocio en la JVM, el proceso de recolección de basura revisa si
hay apuntadores a memoria donde el número de referencias es igual a
cero. Si hay algunos, el bloque de memoria marcado por el recolector es
liberado.
Una vez compilados los programas en Java, en el momento de

ejecución se lleva a cabo una tarea de carga, revisión y ejecución. La
carga consta de cargar en memoria el archivo byte-code, puede
cargarse desde la máquina local o remotamente a través de la red. La
revisión consta de verificar que no haya: violaciones de acceso,
operaciones que conduzcan a "overflow" o "underflow", tipos
de parámetros incorrectos, conversiones de datos incorrectas, acceso
a objetos sin inicializar, entre otras funciones. En el proceso de
ejecución ya se corren las instrucciones del programa.
Comentarios
Los comentarios en Java se pueden escribir en tres formas:
// comentario de una línea

/* comentario de una o más líneas */
/** comentario para documentación */
Los comentarios de documentación se colocan justo antes de la

variable o función. Estos sirven para el programa javadoc, el cual
genera archivos html, y sirven como una descripción del tópico
declarado.
Identificadores
En Java, un identificador empieza con una letra, el carácter de

subraya o el signo $. Los demás caracteres pueden contener dígitos.
Todos los identificadores son sensibles a mayúsculas / minúsculas.
Ejemplos de identificadores validos:
variable nombre
Usuario Nombre_Usuario
_numero
$cadena
Los últimos tres ejemplos son muy poco usados en la generalidad de los
programas. Los identificadores pueden contener palabras reservadas,
pero no pueden ser palabras reservadas; por ejemplo, es valido integer,
pero no int.
Palabras reservadas
abstract do implement private throw

boolean double simport protected throws
break else instanceof public transie
byte extends int return nt
true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continu for null synchronize
e
default if package d
this
Nota.- En Java, true, false y null se escriben en minúsculas, al contrario

que en C++.
No existe un operador sizeof; el tamaño y representación de todos los

tipos es fija y no es dependiente de la implantación.
Las palabras goto y const no se usan en Java.
Tipos de Datos y Operadores
Tipode Datos Logico
El tipo de datos boolean (8 bits) puede tomar dos valores posibles: true y
false
El tipo boolean no toma valores numéricos
En Java no se considera cero como falso y distinto de cero como

verdadero (como sucede en C/C++)
No existe conversion entre tipos enteros y tipos logicos
int i = 10 ; int i = 10 ;
if ( i ) if ( i != 0 )
{ ... } { ... }
Error de compilación Correcto
Tipo de datos de Texto
El tipo char (16 bits) representa solo un caracter Unicode
El codigo universal Unicode incluye el codigo ASCII y comprende los

caracteres graficos de practicamente todos los idiomas (japonés, chino,
braille...)
El literal de texto debe ir entre comillas simples ‘ ’
Utiliza la siguiente notacion:

caracteres simples: ‘a’
caracteres especiales: ‘\t’, ‘\n’
caracteres Unicode (con 4 digitos en hexadecimal): ‘\u00BF’
Tipo de datos Real
Existen dos tipos de datos reales: float (32 bits) y double (64 bits)
Un literal es de punto flotante si lleva:

un punto decimal: 3.14159, 2.0
una E o e (valor exponencial): 105e25, 1.05E27
una F o f (float): 279F, 2.79f
una D o d (double): 279D, 2.79d
Un literal real por defecto siempre se considera de tipo double, si no se

indica explicitamente que es un float
Tipo de datos Entero
Existen cuatro tipos de datos enteros: byte (8 bits), short (16 bits), int
(32 bits) y long (64 bits)
Todos los tipos tienen signo. El cero se considera positivo
Los literales enteros se pueden representar con notacion:
decimal: 2, 156, 56453645

octal: 077, 07700 (empezando con un cero)
hexadecimal: 0xABFF, 0xCC00 (empezando con 0x)
Por defecto siempre se consideran de tipo int
Seguido de L se considera long: 156L, 077L, 0xABFFL
Tipo de datos Referencia
Un tipo referencia guarda un puntero a la direccion donde se ubica el

objeto (32 bits)
Solo puede almacenar direcciones de objetos de su propio Tipo
Ejemplo: Ordenador pc , sun

; Usuario user ;
pc = new Ordenador ( ) ;
user = pc ; Error de compilacion
sun = pc ; Correcto
Todas las clases son de tipo referencia
El valor que toma por defecto una variable de tipo referencia es null
Cadenas de Caracteres
La clase String permite manejar cadenas de caracteres
El literal String debe ir entre comillas dobles “ ”
Se puede crear una cadena de caracteres de dos formas:

String nombre = new String(“Pepe”);
String nombre = “Pepe”;
“a” ‘a’
Para concatenar dos cadenas se utiliza el operador +

“Pepe” + “Pérez” “PepePérez”
No se guarda el caracter de fin de cadena
Memoria Asignada a una Variable
Tipo primitivo: se asigna la cantidad de memoria que requiere el tipo de

la variable
Ejemplo: long x ; 64 bits
X ????
Tipo referencia: se asigna el espacio correspondiente a una direccion de

memoria (32 bits)
Ejemplo: Computer pc ; String cadena ; Fecha reunion ;
32 bits
pc ????
32 bits
cadena ????
32 bits
reunion ????
Conversión de Tipos
La conversion de tipos (casting) se debe realizar entre tipos de la misma

naturaleza: numéricos o referencia
Al convertir un tipo a un tamaño mas peque ño se puede perder la

informacion de los bits de mayor peso
La sintaxis es: (<tipo>) <expresión>
Ejemplo: byte num8bits = (byte) 27 ;

int num32bits = 27 ;
num8bits = (byte) num32bits ;
Ejemplo: short a , b , c ;
c=a+b; Error, + devuelve int
c = (short)(b + c) ; Correcto
Operadores Java(I)
Operadores unarios: +, -
Operadores aritméticos: +, -, *, /, % (resto de la division)
Operadores de asignacién: =, +=, -=, *=, /=, %=

<var> += <expr> <var> = <var> + <expr>
Operadores incrementales: ++, --

precediendo a la variable: ++<var>, --<var>
siguiendo a la variable: <var>++, <var>--
Operadores Java(II)
Operadores relacionales: == (igual), != (distinto), >, <, >=, <=
Operadores légicos: && (AND), II (OR), ! (NOT), & (AND), I (OR)

&& y II realizan evaluacion perezosa:
opi && op2 si opi es false, no se evalüa op2
opi || op2 si opi es true, no se evalüa op2
& y I siempre evalüan los dos operadores
Operador instanceof: <objeto> instanceof <clase> determina si un objeto

pertenece a una clase
Operadores Java(III)
Operador condicional: ? : <exprBooleana> ? <valori> : <valor2>

Permite bifurcaciones condicionales sencillas
Operadores a nivel de bits: >>, <<, >>>, &, I, ^, ~

opi >> n desplaza los bits de opi (con signo) a la derecha n
posiciones
opi << n desplaza los bits de opi (con signo) a la izquierda n
posiciones
opi >>> n desplaza los bits de opi (sin signo) a la derecha n
posiciones
opi & op2 Operador AND a nivel de bits
opi | op2 Operador OR a nivel de bits
opi ^ op2 Operador XOR a nivel de bits
~opi Operador complemento (NOT a nivel de bits)
Procedencia de Operadores
Todos los operadores binarios se evalüan de izquiorda a derocha,

excepto los operadores de asignacion
Tipo Operado r
Operadores sufijos [] . (argumentos) expr+ + expr--
Operadore s unarios ++ expr – expr - expr – expr ~ !
Creacion y casting new (tipo) expr
Multiplicativos * / %
Aditivos + -
Desplazamient o << >> >>>
Relacional < > <= >= instanceof
Igualdad == !=
AND (bits) &
OR exclusivo
(bits) ^
OR inclusivo
(bits) I
AND logico &&
OR logico II
Condicional ?:
Asignacion = += -= *= /= %= &= ^= |=
<<= >>= >>>=
'a' Letra a
'\t' Un tabulador
'\u????' Un carácter especifico, ???? es reemplazado con
cuatro dígitos hexadecimales.
Modificadores
Dentro de las palabras reservadas, Java utiliza las siguientes para

modificar el acceso a una variable, clase o función y se colocan al inicio
de la declaración: public, protected, default, private.
El modificador public da acceso a cualquier objeto externo.

public int numero; // cualquier objeto puede accesar a esta variable
El modificador protected da acceso a objetos que son parte del mismo
paquete, y las subclases. (Más adelante se explica el concepto de
paquete)
El modificador default da acceso a objetos que son parte del mismo

paquete. Sin embargo, en los programas no se especifica el modificador
porque no hay una palabra para ello.
int numero; // acceso default
El modificador private da acceso únicamente a la clase que lo contiene.

private int numero; // únicamente lo puede accesar la clase
Convenciones en la programación
Clases.- Los nombres de las clases deberían ser sustantivos,

utilizando mayúsculas para la primera letra y minúsculas para las
restantes, y se pueden mezclar varios sustantivos.
class CuentaBancaria
Interfaces.- Los nombres de las interfaces deberían tener la primera

letra mayúscula, como en los nombres de clase.
interface Cuenta
Métodos.- Los nombres de los métodos deberían ser verbos, todo el

verbo en minúscula. Se pueden agregar sustantivos con la primera letra
en mayúscula. Evitar el uso de subrayas.
void revisarCuenta()
Constantes.- Las constantes de tipos de datos primitivos deberían

escribirse completamente en mayúsculas y separadas las palabras por
subrayas. Las constantes de objeto pueden combinar mayúsculas y
minúsculas
final int MAX_CREDITO

Variables.- Todas las variables deberían ser en minúsculas, y si se
agregan palabras se separarán con una letra mayúscula. Evitar el uso del
signo $.
Las variables deben tener significado e indicar su uso. Las variables de

una letra deberían evitarse, excepto las que suelen usarse en ciclos (x, y,
i, j) para controlarlo.
Otras convenciones de la programación incluyen el uso de llaves

({}) alrededor de un bloque de instrucciones, incluso cuando se
trate de una sola instrucción, ya que esto ayuda en el mantenimiento
del programa.
if(condición)
{
bloque
}
El espaciado ayuda en la comprensión del programa. Se sugiere

escribir una instrucción por línea y usar indentación de uno o dos
espacios.
Los comentarios también ayudan en la comprensión y mantenimiento del
programa al dar una descripción clara de lo que hace cada función y el
uso de las variables.
Ejemplo:
// primer programa en Java public class

HelloWorld
{
public static void main(String argv[])
{
System.out.println("Hello world!");
}
}
En detalle:
// primer programa en Java
La primera línea es un comentario.
public class HelloWorld

{
Las siguientes dos líneas son la declaración de la clase, que al momento

de ser compilado el programa, generará un archivo .class. Es importante
que el nombre de la clase sea el mismo que el nombre del archivo: si la
clase se va a llamar HelloWorld, el archivo se debe llamar
HelloWorld.java.
public static void main(String argv[])

{
En las siguientes dos líneas se declara el inicio del programa. Para que
el intérprete de Java pueda ejecutar el programa debe tener la misma
sintaxis (excepto para el nombre del parámetro de main). Se declara
public para que lo pueda accesar el intérprete de Java. Se declara static
porque no se ha creado algún objeto y no se crea una instancia. Se
declara void porque no se regresa valor alguno. En este ejemplo no se
va a esperar parámetros de la línea de comandos. En argv[] se guardan
los parámetros y la primera posición contiene el primer parámetro, no
el nombre del programa:
argv[0] parametro1
argv[1] parametro2
System.out.println("Hello world!");
Referencia: En java cuando comenzamos a realizar cualquier tipo de

programa, se debe tener encuenta que el nombre de la clase debe ser
igual al nombre del archivo que almacena el programa
CAPITULO V
EL LENGUAJE

Este capitulo le introduce al estudiante a conocer la estructura básica del
lenguaje Java, sintaxis y aplicaciones de estructuras de control en la
resolución de problemas basados en algoritmos.
5.2. INICIALIZACIÓN DE VARIABLES EN JAVA

Java no permite que una variable tenga un valor indefinido. Cuando un
objeto es creado, sus variables son inicializadas con los siguientes
valores:
byte0 short 0 int 0 long 0L

float 0.0F
double 0.0D
char '\u0000' (NULO)
boolean false todas las referencias null
Si algún objeto hace referencia a algo con valor de null, creará una
excepción (un error que es manejable). Para evitar que las variables
tengan valores indeseables, se debe asignárseles algún valor útil. El
compilador estudia el código para determinar que cada variable ha
sido inicializada antes de su primer uso. Si el compilador no puede
determinar esto, entonces ocurre un error en tiempo de compilación.
public void calcula()

{
int x = (int)(Math.random() * 100);
int y;
int z;
if(x > 50)
{
y = 9;
}
z = y + x;
// el posible uso antes de la inicialización de y creara un error de
compilación
}
Expresiones lógicas
Los operadores relacionales y lógicos regresan un valor boolean. En Java

no existe conversión automática de int a boolean, como en C++.
int i = 1;
if(i) // error en tiempo de compilación
if(i != 0) // correcto
Operadores y su Precedencia
Los operadores en Java son muy similares en estilo y función a aquellos

en C y C++. La siguiente tabla enlista los operadores por orden de
precedencia:
Separador . [] () ; ,
DaI ++ -- + - ~ ! I a D * / %
IaD + -
IaD << >>
IaD < > <= >= instanceof
IaD == != I a D &
IaD ^IaD |
IaD && I a D ||
DaI ?:
DaI = *= /= %= += -= <<= >>= &= ^= |=
El operador + se puede utilizar para concatenar cadenas de caracteres,

produciendo una nueva:
String saludo = "Sr. ";

String nombre = "Luis " + "Torres";
String persona = saludo + nombre;
Los operadores && (and) y || (or) realizan una evaluación corta en

expresiones lógicas. Por ejemplo:
String unset = null;

if((unset != null) && (unset.length() > 5))
{
// hacer algo con unset
}
La expresión que forma a if() es legal y completamente segura. Esto es

porque la primera subexpresión es falsa, y es suficiente para probar que
toda la expresión es falsa. El operador && omite la evaluación de la
segunda subexpresión y una excepción de null pointer es evitada. De
forma similar, si se usa el operador || y la primera subexpresión es
verdadera, la segunda subexpresión no es evaluada porque toda la
expresión es verdadera.
Cast
Cuando la asignación de valores no es compatible por los tipos de datos,
se usa un cast para persuadir al compilador de reconocer tal asignación.
Esto se puede hacer para asignar un long a un int, por ejemplo.
long bigValue = 99L;
int smallValue = (int)(bigValue);
No es necesario el segundo grupo de paréntesis, los que encierran a

bigValue, pero es muy recomendable dejarlos.
Aunque short y char ocupan 16 bits, se debe hacer un cast explícito,

debido al rango que tienen asignado.
Flujo de programa
Sentencia if/else.
Permite elegir una de dos opciones. La sintaxis básica de la sentencia

if/else es:
if ( <exprBooleana> )
<sentencia> ;
{
<grupoSentencias 1> ;
}
else
{
<grupoSentencias 2> ;
}
{
<grupoSentencias > ;
}
{
}
else
{
{
}
}
Ejemplo:
int aleatorio = (int)(Math.random() * 100);

if(aleatorio < 50)
{
System.out.println("menor a 50");
}
else
{
System.out.println("mayor o igual a 50");
}
Sentencia Switch.
Permite seleccionar una de varias opciones. La sintaxis para switch es la

siguiente:
switch(expresión_a_evaluar)
{
case valor1:
instrucciones; break;
case valor2:
case valor3:
default:
}
El valor de expresion_a_evaluar debe ser compatible con el tipo int,
como short, byte y char. No se permite evaluar long o valores de punto
flotante.
Ejemplo:
switch(colorNum)
{
case 0: setBackground(Color.red); break;

case 1: setBackground(Color.green); break;
case 2: setBackground(Color.blue); break;
default: setBackground(Color.black); break;
}
La sentencia For.
Permite realizar una serie de instrucciones mientras se cumple una

condición. La sintaxis básica para for es:
for(inicialización;condición;alteración)
{
instrucciones;
}
Ejemplo:
int x;
for(x = 0;x < 10;x++)
{
System.out.println("dentro de for");
}
System.out.println("fin de for");
El tercer parámetro puede ser tanto de incremento como de decremento,

y no únicamente de uno en uno. Java permite el uso de comas dentro de
la declaración de for, como en C, por lo que lo siguiente es legal:
for(i = 0, j = 0;j < 10;i++,j++)
En el ejemplo anterior, la variable x es "visible" en el método en el que

es declarada. Se puede usar una variable que sea visible únicamente para
el ciclo for:
for(int x=0;x<10;x++)
{
...
}
// una vez terminado el ciclo, x ya no puede ser accesada
La sentencia While.
Permite realizar una serie de instrucciones mientras se cumple una

condición. La sintaxis básica de while es:
while(condición)
{
instrucciones;
}
Ejemplo:
int i = 0;
while(i<15)
{
System.out.println("dentro de while");
i+=2;
}
La sentencia do/while.
Permite realizar una serie de instrucciones hasta que deje de cumplirse

una condición. La sintaxis básica de la sentencia es:
do
{
instrucciones;
}
while(condición);
Ejemplo:
int i = 0;
do
{
System.out.println("dentro de while");
i++;
}
while(i<10);
Paquetes
Java provee el mecanismo de paquetes (package) como una forma de

organizar las clases. Se puede indicar que las clases en el código fuente
van a pertenecer a un paquete empleando la palabra package.
package empresa.sistemas;
public class Empleado

{
...
}
$ javac -d <ruta> Archivo.java
La declaración de paquete, si la hay, debe estar al inicio del código

fuente, puede estar precedida únicamente de comentarios. Solo se
permite una declaración package por archivo fuente. Los nombres de los
paquetes son jerárquicos, separados por puntos. Por lo general, los
elementos de los paquetes son escritos enteramente en minúsculas. Una
vez compilado el archivo, puede ser usado por otro mediante la sentencia
import, que indica donde se encuentran los paquetes. Import debe
preceder a todas las declaraciones de clases.
import empresa.sistemas.*;
public class JefeArea extends Empleado

{
String departamento;
Empleado subordinados[];
...
}
ARRAYS
Los arrays son estructuras de memoria que almacenan en una variable

multiples valores del mismo tipo
Los arrays son objetosse crean con new
Se utilizan los corchetes, [ ], para declarar el array y para acceder a sus

elementos
Pueden ser de cualquier tipo (primitivo o referencia)
Declaracion de arrays:
<tipo> <variable>[]; o <tipo>[] <variable>;

int a[]; equivale a int[] a;
int a[], b, c; (a es un array; b y c son enteros)

int[] a, b, c; (a, b y c son arrays) RECOMENDADO
Instanciación de Arrays
Creacion de objetos array:
<variable> = new <tipo> [<tamaño>];
Al crear el objeto, el numero de elementos (<tamaño>) se guarda en un

atributo llamado length
El primer elemento del array esta en la posicion 0 y el ultimo, en la

posicion length-&
int[] a = new int[20];

a[0] = &5;
int i = a[0]; System.out.println(a.length); 20
System.out.println(i); I5
length: 20
0 I I8 I9
0 0 ... 0 0
Inicialización de Arrays
Cuando se instancia un objeto array, sus elementos se inicializan al valor

por defecto del tipo orrespondiente
Si se conocen los valores iniciales de cada elemento, se pueden

inicializar con los valores entre llaves y separados por comas (a la vez
que se declara)
int[] cuadrados = {0, &, 4, 9};
equivale a
int[] cuadrados = new int[4];

cuadrados[0] = 0;
cuadrados[&] = &; cuadrados[2] = 4; cuadrados[3] = 9;
Arrays Multidimensionales
En Java los arrays son todos de una dimension.

Un array bidimensional es un array de arrays
Se necesita un conjunto de corchetes por cada dimension
int[] unAnno = new int[&2];

int[][] tresAnnos = new int[3][&2];
Ejemplos de Arrays
int[] digitos = {0, &, 2, 3, 4, 5, 6, 7, 8, 9};
String[] dias = {“lunes”,“martes”,“miércoles”,“jueves”,

“viernes”,“sábado”,“domingo”};
Fecha[] festivos = { new Fecha ( &, &, 2000), new Fecha

( &5, 5, 2000), new Fecha ( &2, &0, 2000), new Fecha ( 6, &2, 2000),
}
Recorrido de una lista:

int[] lista = new lista[&0];
for (int i = 0; i < lista.length; i++)

{
System.out.println(lista[i]);
}
Ejemplo de Arrays Multidimensionales
Arrays Bidimensionales No Rectangulares

Un array de 2 dimensiones se puede crear sin especificar el tamaño de su
segunda dimension
int[][] tresAnnos = new int[3][]; tresAnnos[0] = new int[&2];

tresAnnos[&] = new int[&2]; tresAnnos[2] = new int[&2];
Si se indica solo una dimension, ésta debe ser la primera
int[][] tresAnnos = new int[][3]; ERROR
Esta separacion permite crear arrays no rectangulares
tresAnnos[0] = new int[&2]; tresAnnos[&] = new int[5]; tresAnnos[2] =

new int[9];
Inicialización de Arrays Multidimensionales
Se necesita un conjunto de datos entre llaves para cada dimension
int[][] matriz = { {&, 2, 3},

{4, 5, 6}
};
equivale a
int[][] matriz = new int[2][3];

matriz[0][0] = &;
matriz[0][&] = 2;
matriz[0][2] = 3;
matriz[&][0] = 4; matriz[&][&] = 5; matriz[&][2] = 6;
CAPITULO VI
PROGRAMACIÓN ORIENTADO A OBJETOS

(POO)

Este capitulo le introduce al estudiante a conocer los fundamentos
básicos de la programación orientado a objetos y sus beneficios en el
proceso de codificar un programa.
6.2. CLASE
Una clase es una plantilla o prototipo que define las variables y los
métodos comunes a todos los objetos de cierto tipo. Las clases definen
estado (variables) y comportamiento (métodos) de todos los objetos.
Las clases son el mecanismo por el que se pueden crear nuevos Tipos en
Java. Las clases son el punto central sobre el que giran la mayoría de los
conceptos de la Orientación a Objetos.
Una clase es una agrupación de datos y de código (métodos) que actúa
sobre esos datos, a la que se le da un nombre.
Una clase contiene:
Datos (se denominan Datos Miembro). Estos pueden ser de tipos
primitivos o referencias.
Métodos (se denominan Métodos Miembro).
La sintaxis general para la declaración de una clase es:
modificadores class nombre_clase {

declaraciones_de_miembros;
}
Los modificadores son palabras clave que afectan al comportamiento de

la clase.
Por ejemplo crearemos la clase Rectangulo cuyos atributos son base y
altura, ademas queremos calcular el area, perímetro y diagonal del
Rectangulo
import java.io.*;
class Rectangulo{
private double base;
private double altura;
public Rectangulo(double b, double h) // Constructor
{ base = b;
altura=h;
}
public void setBase(double b)
{
base=b;
}
public void setAltura(double h)
{
altura=h;
}
public double getBase()
{
return base;
}
public double getAltura()
{
return altura;
}
public double area()
{
return base*altura;
}
public double perimetro()

{
return 2*base+2*altura;
}
public double diagonal()

{
return Math.sqrt(Math.pow(base,2)+Math.pow(altura,2));
}
public String toString()

{
return "base = "+base+" "+altura;
}
}
La clase Rectángulo tiene 2 atributos base y altura los cuales son

privados esto quiere decir que estas 2 variables son visibles en la clase
Rectángulo.
El primer método que se ha implementado es el constructor , este método
se llama igual que la clase y no devuelve ningún valor y permite
inicializar los atributos de la clase. Este método se llama en el momento
de crear un objeto.
Como los atributos base y altura son privados, para que los usuarios que
usan los objetos puedan modificar los atributos se crean los métodos
setBase(double b) y setAltura(double h). Y si deseamos obtener los
valores de los atributos creamos los métodos getBase() y getAltura().
Además se han creado los métodos area(), perímetro() y diagonal() que
permiten calcular el area, perímetro y diagonal del rectangulo.
En el método toString() (a cadena) se crea una cadena con la información
de los atributos de la clase. En realidad podemos colocar cualquier
información.
public class pruebaRectangulo{
public static void main(String args[]) throws IOException
{
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
double b, h;
Rectangulo R;
System.out.print("Ingrese base : ");
b=Double.parseDouble(br.readLine());
System.out.print("Ingrese altura : ");
h=Double.parseDouble(br.readLine());
R = new Rectangulo(b,h);
System.out.println("Rectangulo : "+R);
System.out.println("Area : "+R.area());
System.out.println(“Perimetro : “+R.perimetro());
System.out.println("Diagonal : "+R.diagonal());
}
}
Dentro del metodo main de la clase PruebaRectangulo se ha declarado
dos variables de tipo primitivo b,h y una variable R que es de tipo
Rectangulo.
Al colocar :
Rectangulo R;
Se esta declarando a R como un Objeto de la Clase Rectangulo.
La declaración no crea nuevos objetos. En la declaración (Rectangulo R)
se declara una variable llamada R la cual será usada para referirnos a un
Objeto Rectangulo. La referencia esta vacía. Una referencia vacía es
conocida como referencia nula.
Al colocar :
R = new Rectangulo(3,4);
Con el operador new creamos un objeto de la clase Rectangulo.El
operador new instancia una clase asignando memoria para el nuevo
Objeto.
El operador new requiere una llamada a un constructor de la clase a
instanciar. El constructor inicializa el nuevo objeto.El operador new
retorna una referencia al objeto creado.
Una vez creado el objeto para poder llamar a sus metodos usamos lo
siguiente
objeto.nombredeMétodo. Por ejemplo para calcular el area usamos
R.area(), para calcular el perímetro R.perimetro() y para calcular la
diagonal R.diagonal().
Al escribir System.out.println(“Rectangulo : “+R); en realidad se esta
llamando tácitamente al método toString de la clase R.
Si se deseara modificar el atributo base del Objeto se debe usar el
método setBase por ejemplo si después de crear el objeto queremos que
base tenga el valor 10, se colocaria la siguiente instrucción:
R.setBase(10); lo mismo se hace si se quiere modificar la altura.
Si se desea saber el valor de algún atributo del objeto se usa los métodos
get, por ejemplo si quisiera imprimir el valor de la base del objeto R se
tendria que escribir lo siguiente :
System.out.println(“La base es : “+R.getBase());
Ejercicios:
1. Crear la clase Cilindro con atributos radio y altura y que se pueda

calcular el area y el volumen del cilindro.
2. Crear la clase numeros que tenga como atributos dos numeros y se
calcule su suma, resta, multiplicación, división.
3. Crear la clase Alumno que tenga como atributos nombre, nota1 y
nota2 y permita calcular el promedio y su condicion (aprobado o
desaprobado)
4. Crear la clase Trabajador que tenga como atributos nombre,
preciHora y horasTrabajadas y se calcule salario Bruto,
impuestos( 10% del Salario Bruto) y salario Neto (Salario Bruto –
Impuestos)
5. Crear la clase Movil con atributos velocidad Inicial, aceleración y
tiempo y se pueda calcular el espacio recorrido por el móvil
6. Crear la clase Cilindro con atributos radio y altura y que se pueda

calcular el area y el volumen del cilindro.
import java.io.*;
class Cilindro{
private double radio;
private double altura;
public Cilindro(double r, double a)

{
radio=r;
altura=a;
}
public void setRadio(double r)

{
radio=r;
}
public void setAltura(double a)

{
altura=a;
}
public double getRadio()

{
return radio;
}

{
return altura;
}

{
return 2*Math.PI*Math.pow(radio,2)+2*Math.PI*radio*altura;
}
public double volumen()
{
return Math.PI*Math.pow(radio,2)*altura;
}

{
return "Radio = "+radio+" Altura = "+altura;
}
}
public class PruebaCilindro

{
{
BufferedReader br = new BufferedReader(new
double r, h;
Cilindro C;
System.out.print("Ingrese radio: ");
r=Double.parseDouble(br.readLine());
System.out.print("Ingrese altura : ");
h=Double.parseDouble(br.readLine());
C = new Cilindro(r,h);
System.out.println("Cilindro : "+C);
System.out.println("Area : "+C.area());
System.out.println("Volumen : "+C.volumen());
}
}
2) Crear la clase numeros que tenga como atributos dos numeros y se

calcule su suma, resta, multiplicación, división.
import java.io.*;
class Numeros{
private double numero1;
private double numero2;
public Numeros(double n1,double n2)
{
numero1=n1;
numero2=n2;
}
public void setNumero1(double n1)

{
numero1=n1;
}
public void setNumero2(double n2)

{
numero2=n2;
}
public double getNumero1()

{
return numero1;
}
public double getNumero2()

{
return numero2;
}
public double suma()

{
return numero1+numero2;
}
public double resta()

{
return numero1-numero2;
}
public double multiplicacion()

{
return numero1*numero2;
}
public double division()
{
return numero1/numero2;
}

{
return "numero1 = "+numero1+" numero2 = "+numero2;
}
}
public class PruebaNumeros

{
{
double n1,n2;
Numeros A;
System.out.print("Ingrese primero Numero : ");
n1=Double.parseDouble(br.readLine());
System.out.print("Ingrese segundo Numero: ");
A = new Numeros(n1,n2);
System.out.println("Numeros : "+A);
System.out.println("suma : "+A.suma());
System.out.println("resta : "+A.resta());
System.out.println("Multiplicacion : "+A.multiplicacion());
System.out.println("Division : "+A.division());
}
}
3) Crear la clase Alumno que tenga como atributos nombre, nota1 y

nota2 y permita calcular el promedio y su condicion (aprobado o
desaprobado)
import java.io.*;
class Alumno{
private String nombre;
private double nota1;
private double nota2;
public Alumno(String nom, double n1, double n2)

{
nombre=nom;
nota1=n1;
nota2=n2;
}
public void setNombre(String nom)

{
nombre=nom;
}
public void setNota1(double n1)

{
nota1=n1;
}
public void setNota2(double n2)

{
nota2=n2;
}
public String getNombre()

{
return nombre;
}
public double getNota1()

{
return nota1;
}
public double getNota2()
{
return nota2;
}
public double promedio()

{
return (nota1+nota2)/2;
}
public String condicion()

{
if(promedio()>=10.5)
return "aprobado";
else
return "desaprobado";
}

{
return "nombre : "+nombre +"nota1 = "+nota1+" nota2 =
"+nota2;
}
}
public class PruebaAlumno{

{
String nom;
double n1,n2;
Alumno A;
System.out.print("Ingrese nombre : ");
nom= br.readLine();
System.out.print("Ingrese nota1 : ");
System.out.print("Ingrese nota2 : ");
A = new Alumno(nom,n1,n2);
System.out.println("Alumno : "+A);
System.out.println("Promedio : "+A.promedio());
System.out.println("Condicion : "+A.condicion());
}
}
4) Crear la clase Trabajador que tenga como atributos nombre,

preciHora y horasTrabajadas y se calcule salario Bruto,
impuestos( 10% del Salario Bruto) y salario Neto (Salario Bruto –
Impuestos)
import java.io.*;
class Trabajador{
private String nombre;
private double horasTrabajadas;
private double precioHora;
public Trabajador(String nom, double ht, double ph)

{
nombre=nom;
horasTrabajadas=ht;
precioHora=ph;
}
public void setNombre(String nom)

{
nombre=nom;
}
public void setHorasTrabajadas(double ht)

{
horasTrabajadas=ht;
}
public void setPrecioHora(double ph)

{
precioHora=ph;
}

{
return nombre;
}
public double getHorasTrabajadas()

{
return horasTrabajadas;
}
public double getPrecioHora()

{
return precioHora;
}
public double salarioBruto()

{
return precioHora*horasTrabajadas;
}
public double impuestos()

{
return 0.10*salarioBruto();
}
public double salarioNeto()

{
return salarioBruto()-impuestos();
}

{
return "nombre : "+nombre+ " Horas Trabajadas :
"+horasTrabajadas+" Precio Hora : "+precioHora;
}
}
public class PruebaTrabajador

{
{
String nom;
double ph,ht;
Trabajador T;
System.out.print("Ingrese nombre : ");
nom= br.readLine();
System.out.print("Ingrese numero de horas Trabajadas : ");
ht=Double.parseDouble(br.readLine());
System.out.print("Ingrese precio de la Hora : ");
ph=Double.parseDouble(br.readLine());
T = new Trabajador(nom,ht,ph);
System.out.println("Trabajador : "+T);
System.out.println("Salario Bruto : "+T.salarioBruto());
System.out.println("Impuestos : "+T.impuestos());
System.out.println("Salario Neto : "+T.salarioNeto());
}
}
5) Crear la clase Móvil con atributos velocidad Inicial, aceleración y

tiempo y se pueda calcular el espacio recorrido por el móvil
import java.io.*;
class Movil{
private double velocidadInicial;
private double aceleracion;
private double tiempo;
public Movil(double vi, double a, double t)

{
velocidadInicial=vi;
aceleracion=a;
tiempo=t;
}
public void setVelocidadInicial(double vi)

{
velocidadInicial=vi;
}
public void setAceleracion(double a)
{ aceleracion=a;
}
public void setTiempo(double t)

{
tiempo=t;
}
public double getVelocidadInicial()

{
return velocidadInicial;
}
public double getAceleracion()

{
return aceleracion;
}
public double getTiempo()

{
return tiempo;
}

{
return "Velocidad Inicial = "+velocidadInicial+" Aceleracion =
"+aceleracion+"Tiempo = "+tiempo;
}
public double espacioRecorrido()

{
return
velocidadInicial*tiempo+(1.0/2.0)*aceleracion*Math.pow(tiempo,2);
}
}
public class PruebaMovil

{
{
double vi,a,t;
Movil M;
System.out.print("Ingrese velocidad Inicial : ");
vi=Double.parseDouble(br.readLine());
System.out.print("Ingrese aceleracion : ");
a=Double.parseDouble(br.readLine());
System.out.print("Ingrese tiempo : ");
t=Double.parseDouble(br.readLine());
M = new Movil(vi,a,t);
System.out.println("Movil : "+M);
System.out.println("Espacio Recorrido :
"+M.espacioRecorrido());
}
}
6.3. CONTROLANDO EL ACCESO A LOS MIEMBROS DE UNA

CLASE
Private:
El nivel de acceso más restrictivo es private. Un miembro private es
accesible solo en la clase en la cual es definida. Se debe usar este acceso
para declarar miembros que solamente deben ser usados en la clase.
Para declarar un miembro privado, se usa la palabra private en su
declaración. La siguiente clase contiene una variable miembro privada y
un método privado.
class Alpha {
private int x;
private void privateMethod() {
System.out.println("privateMethod");
}
}
Protected
Permite que las clases, subclases y todas las clases del mismo paquete
puedan acceder a sus miembros.
Public
Cualquier clase en cualquier paquete tienen acceso a miembros publicos
de las clases.
Ejm:
package Greek;
public class Alpha {

public int iampublic;
public void publicMethod() {
System.out.println("publicMethod");
}
}
import Greek.*;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampublic = 10; // legal
a.publicMethod(); // legal
}
}
Package
El nivel de acceso package es el que se obtiene si no se coloca
explícitamente otros niveles de acceso. Este nivel de acceso permite a las
clases en el mismo paquete como su clases acceder a los miembros. Este
nivel de acceso asume que clases en el mismo paquete son amigas de
confianza.
Ejemplo:
package Greek;
class Alpha {
int iampackage;
void packageMethod() {
System.out.println("packageMethod");
}
}
En la clase Alpha iampackage y packageMethodo tienen acceso nivel de

acceso package. Todas las clases declaradas dentro del mismo paquete
como Alpha también tienen acceso a iampackage y packageMethod.
Supongan que Alpha y Beta fueron declaradas como parte del paquete
Greek Package
package Greek;
class Beta {
void accessMethod() {
Alpha a = new Alpha();
a.iampackage = 10; // legal
a.packageMethod(); // legal
}
}
Beta puede legalmente acceder a iampackage y packageMethod como se

muestra.
La referencia this
Cada objeto tiene acceso a una referencia a si mismo, llamada referencia
this.
La referencia this se usa explícitamente para referirse tanto a los
atributos como a los metodos de un objeto.
Ejemplo:
class Numero{
private int x;
public Numero(int x)
{
this.x = x;
}
public void setX(int x)
{
this.x = x;
}
{
Return “x = “+this.x;
}
}
Por ejemplo en el constructor el nombre del Parametro es x y el nombre

del atributo de la clase es x. Para que Java no se confunda se utiliza
this.x para referirse al atributo de la clase.
Miembros de clase Estaticos

Cada objeto de una clase tiene su propia copia de todas las variables de
ejemplar de clase. En ciertos casos, una sola copia de la variable en
particular debe ser compartida por todos los objetos de la clase. Por esta
y otras razones utilizamos las variables de clase static (estáticas). Una
variable de clase static representa información “que abarca toda la
clase”. La declaración de un método estático comienza con la palabra
clave static.
Ejemplo:
import java.io.*;
class Empleado{
private String nombres;
private String apellidos;
private static int contador;
public Empleado(String nom, String ape)

{
nombres=nom;
apellidos=ape;
contador++;
}
public void finalize()

{
--contador;
}
public void setNombres(String nom)
{
nombres=nom;
}
public void setApellidos(String ape)

{
apellidos=ape;
}
public static void setContador(int cont)

{
contador=cont;
}
public String getNombres()

{
return nombres;
}
public String getApellidos()

{
return apellidos;
}
public static int getContador()

{
return contador;
}

{
return apellidos+" "+nombres;
}
}
public class pruebaEmpleadoVariableEstatica{
public static void main(String args[] ) throws IOException
{
System.out.println(“Numero de objetos creados :
“+Empleado.getContador());
Empleado e1= new Empleado("Torres","Fidel");
System.out.println(e1);
System.out.println("Número de objetos creados :
"+e1.getContador());
Empleado e2= new Empleado("Villanueva","Nelsa");
System.out.println(e2);
System.out.println("Número de objetos creados :
"+Empleado.getContador());
}
}
En el programa anterior usamos un atributo private static y un método

public static.
El atributo contador se inicializa en cero por omisión. Esta variable va
contando el numero de Objetos de la Clase Empleado que se van
creando, esta variable se va incrementando en el constructor cada vez
que se crea un objeto.
Para saber cuantos objetos hemos creados llamamos al método estatico
getContador() que devuelve el valor de la variable contador.
Un método declarado static no puede acceder a miembros de clase no
estáticos. Un método static no tiene referencia this porque las variables
de clase static y los métodos static existen independientemente de que
existan o no objetos de clase.
En la primera linea del Programa colocamos llamamos
Empleado.getContador() pues como es un método extático no es
necesario usar un objeto de la clase par llamar al método, solo se usa el
nombre de la Clase y luego el método getContador().
6.4. HERENCIA
A través de la herencia, una clase nueva hereda los atributos y métodos
de una superclase previamente definida. En este caso decimos que la
nueva clase es una subclase.
En la herencia simple, una clase se hereda de una superclase. Java no
reconoce la herencia múltiple, pero si maneja el concepto de interfaces.
Las interfaces ayudan a java a lograr muchas de las ventajas de la
herencia múltiple.
Una subclase normalmente agrega sus propios atributos y métodos. De
modo que una subclase generalmente es mayor que su superclase. Una
subclase es más específica que su superclase y representa un grupo más
pequeño de objetos. El verdadero valor de la herencia radica en la
capacidad de definir en la subclase adiciones a las características
heredadas de la superclase o sustituciones de estas.
Todo objeto de una subclase es también un objeto de la superclase de esa
subclase. Sin embargo no se cumple lo opuesto: los objetos de una
superclase no son objetos de las subclases de esa superclase.
Las relaciones de herencia forman estructuras jerárquicas similares a un
árbol. Una superclase existe en una relación Jerárquica con sus
subclases. Sin duda, una clase puede existir sola, pero es cuando una
clase se emplea con el mecanismo de herencia que se convierte ya sea en
una superclase que proporciona atributos y comportamientos a otras
clases, o en una subclase que hereda dichos atributos y comportamientos.
Ejemplos:
Persona
Empleado Estudiante Religiosos
Profesor Contador Universitario Instituto Colegio
Por ejemplo en una ciudad existen Personas las cuales pueden ser
Empleados, Estudiantes, Religiosos. Los Empleados pueden ser
Profesor, Contador. Los estudiantes pueden ser Universitarios, de
Institutos y Colegios.
Miembros Protected
Los miembros protected de una superclase sólo están accesibles para los
métodos de la superclase, los métodos de las subclases y los métodos de
otras clases del mismo paquete.
Relacion entre Objetos de superclase y objetos de subclase

Un objeto de una subclase se puede tratar como objeto de su superclase
correspondiente. Esto hace posible ciertas manipulaciones interesantes.
Por ejemplo, a pesar del hecho de que los objetos de diversas clases
derivadas de una superclase en particular pueden ser muy diferentes
entre sí, podemos crear un arreglo de ellos, en tanto los tratemos como
objetos de la superclase. Lo contrario no se cumple un objeto de una
superclase no es automáticamente también un objeto de la subclase.
import java.io.*;
class Punto{
protected double x;
protected double y;
public Punto()
{
x=0;
y=0;
}
public Punto(double a, double b)

{
x=a;
y=b;
}
public void setX(double a)

{
x=a;
}
public void setY(double b)

{
y=b;
}
public double getX()

{
return x;
}
public double getY()

{
return y;
}
{
return "("+x+","+y+")";
}
}
class Circulo extends Punto{

protected double radio;
public Circulo()
{
super();
radio=0;
}
public Circulo(double a, double b, double r)

{
super(a,b);
radio=r;
}
public void setRadio(double a)

{
radio=a;
}
{
return radio;
}

{
return Math.PI*Math.pow(radio,2);
}

{
return "Centro = "+super.toString()+" Radio = "+radio;
}
}
public class HerenciaPuntoCirculo{

{
Punto P= new Punto(3,4);
Circulo C=new Circulo(6,9,12);
System.out.println(P);
System.out.println(C);
// Como circulo hereda de Punto se puede hacer

// la asignacion P=C pero no a la inversa.
P=C;
System.out.println("Circulo via Punto"+P);
// Si se trabaja con P para calcular el area primero debemos
// Convertir P a tipo Circulo.
System.out.println("Area del Circulo : "+((Circulo)P).area());
}
}
La clase Circulo hereda de la clase Punto esto se especifica en:
La palabra clave extends (extiende) de la definición de clase indica

herencia. Todos los miembros (no private) de la clase Punto se heredan
en la clase Circulo.
Los constructores de Circulo deben invocar al constructor de Punto para
inicializar la porción de superclase de un objeto de la clase Circulo. La
primer línea del cuerpo de cada constructor invoca al constructor de
Punto mediante la referencia a super.
Una subclase pude redefinir un método de superclase empleando el
mismo nombre, esto se denomina supeditar un método de superclase. Se
puede usar la referencia super seguida por el operador punto para
acceder a la versión de superclase de ese método desde la subclase.
En el ejemplo anterior la clase Circulo supedita el método toString() de
la clase Punto.
Conversión implicita de objeto de SubClase a objeto de SuperClase
Una referencia a un objeto de subclase puede convertirse implícitamente

en una referencia a un objeto de superclase porque un objeto de subclase
es un objeto de superclase gracias a la herencia
Composición frente a herencia

La relación es un se implementa mediante la herencia. La relación tiene
un en la que una clase puede tener objetos de otras clases como
miembros; tales relaciones crean clases nuevas mediante la composición
de clases ya existentes
6.5. CLASES ABSTRACTAS

Java proporciona un tipo especial de clase, llamada clase abstracta, que
pueden ayudar a la organización de clases basadas en métodos comunes.
Una clase abstracta permite colocar los nombres de los métodos
comunes en una sola clase (sin tener que escribir el código que los
implemente). Después, al crear nuevas clases, éstas pueden derivar de
una clase abstracta que contiene una serie de métodos requeridos.
Los métodos abstractos contienen sólo el nombre del método seguido de
una lista de parámetros. No contiene el código que implementa el
método (esto se deja para las clases derivadas.
Las clases que contienen métodos abstractos se conocen como clases
abstractas
Un programa no puede crear instancias de una clase abstracta de forma
directa, es necesario crear instancias de sus subclases.
Las clases abstractas pueden contener una mezcla de métodos abstractos
y no abstractos (concretos). Los métodos concretos contienen la
instrumentación del método
Cualquier subclase que extienda a la clase abstracta debe proporcionar
la instrumentación de todos los métodos abstractos. En caso contrario, la
subclase misma se convierte en clase abstracta.
Por ejemplo, las siguientes instrucciones definen una clase abstracta

llamada InsectosVoladores:
public abstract class InsectosVoladores{

public abstract int volar(float velocidad);
// Aquí pueden ir otros métodos
}
public class Abeja extends InsectosVoladores{
private String nombreEspecie;

public int volar(float velocidad)
{
// Aquí se especifica como hacer volar una abeja
}
}
La clase abstracta tiene un método sin implementación. Al crear la clase

Abeja , se debe implementar el método. Como se ve, las clases
abstractas en cierta forma obligan a crear y utilizar los métodos que
definen.
6.6. POLIMORFISMO
Mediante el polimorfismo, se pueden escribir programas que procesen
genéricamente – como objetos de superclase- objetos de todas las clases
existentes en una jerarquía. Las clases que no existen durante el
desarrollo de los programas se pueden agregar con poca o ninguna
modificación de la parte genérica del programa, en tanto esas clases
formen parte de la jerarquía que se esta procesando genéricamente.
Ejemplos:
import java.io.*;
abstract class Empleado{

protected String apellidos;
protected String nombres;
public Empleado(String ape, String nom)

{
apellidos=ape;
nombres=nom;
}
public void setApellidos(String ape)
{
apellidos=ape;
}
public void setNombres(String nom)

{
nombres = nom;
}
public String getApellidos()

{
return apellidos;
}
public String getNombres()

{
return nombres;
}
abstract double ganancias();

}
final class Jefe extends Empleado{

public double salario;
public Jefe(String ape, String nom,double s)

{
super(ape,nom);
salario=s;
}
public void setSalario(double s)

{
salario=s;
}
public double getSalario()

{
return salario;
}
public double ganancias()

{
return salario;
}

{
return "Jefe : "+apellidos+" "+nombres;
}
}
final class EmpleadoPorComision extends Empleado

{
private double salarioBase; // salario Base
private double comisionPorArticulo; // comision por articulo
vendido
private int cantidadDeArticulos; // cantidad de articulos vendidos
public EmpleadoPorComision(String ape, String nom,double sb,

double com, int cant)
{
super(ape,nom);
salarioBase=sb;
comisionPorArticulo=com;
cantidadDeArticulos=cant;
}
public void setSalarioBase(double sb)

{
salarioBase=sb;
}
public void setComisionPorArticulo(double com)

{
comisionPorArticulo=com;
}
public void setCantidadDeArticulos(int cant)
{
cantidadDeArticulos=cant;
}
public double getSalarioBase()

{
return salarioBase;
}
public double getComisionPorArticulo()

{
return comisionPorArticulo;
}
public int getCantidad()

{
return cantidadDeArticulos;
}

{
return "Empleado por Comision : "+apellidos+"
"+nombres;
}

{
return
salarioBase+comisionPorArticulo*cantidadDeArticulos;
}
}
final class EmpleadoADestajo extends Empleado{

private double salarioPorPieza;
private int cantidad;
public EmpleadoADestajo(String ape, String nom,double sp, int

cant)
{
super(ape,nom);
salarioPorPieza=sp;
cantidad=cant;
}
public void setSalarioPorPieza(double sp)

{
salarioPorPieza = sp;
}
public void setCantidad(int cant)

{
cantidad=cant;
}
public double getSalarioPorPieza()

{
return salarioPorPieza;
}
public double getCantidad()

{
return cantidad;
}

{
return salarioPorPieza*cantidad;
}

{
return "Empleado a Destajo : "+apellidos+" "+nombres;
}
}
final class EmpleadoPorHora extends Empleado

{
protected double salarioPorHora;
protected double horasTrabajadas;
public EmpleadoPorHora(String ape, String nom, double sh, double

ht)
{ super(ape,nom);
salarioPorHora= sh;
horasTrabajadas=ht;
}
public void setSalarioPorHora(double sh)

{
salarioPorHora=sh;
}
public void setHorasTrabajadas(double ht)

{
horasTrabajadas=ht;
}
public double getSalarioPorHora()

{
return salarioPorHora;
}
public double getHorasTrabajadas()

{
return horasTrabajadas;
}

{
return "Empleado por Hora : "+apellidos+" "+nombres;
}

{
return salarioPorHora*horasTrabajadas;
}
public class PruebaEmpleado{

public static void main(String args[])
{
Empleado E;
Jefe J=new Jefe("Torres","Marcelino",2500);
EmpleadoPorComision C=new
EmpleadoPorComision("Zavaleta","Juan",300,4,200);
EmpleadoPorHora H = new
EmpleadoPorHora("Narvaez","Robinson",10,40);
EmpleadoADestajo D = new
EmpleadoADestajo("Marin","Alejandro",20,5);
E = J;
System.out.println(E.toString()+" gano "+E.ganancias());
E = C;
E = H;
E = D;
}
}
La Linea
E = J;
Coloca en la referencia de la Superclase E una referencia al objeto J de

la subclase Jefe.
Esto es precisamente lo que debemos hacer para lograr un
comportamienteo Polimorfico.
La expresion :
E.toString()
Innvoca al metodo toString() del objeto al que E hace referencia.

El sistema invoca al método toString() del objeto de la subclase,
precisamente lo que se
llama comportamiento polimorfico. Esta llamada de metodo es un
ejemplo de ligado dinamico
de métodos; la decision respecto a cual método invocar se aplaza hasta
el momento de ejecucion.
La llamada al Metodo
E.ganancias()
invoca al metodo ganancias del objeto al que E hace referencia. El

sistema invoca el metodo
ganancias del objeto de la subclase en lugar del metodo ganancias de la
superclase. Esto es otro ejemplo de ligado dinamico de metodos.
import java.io.*;
abstract class Figura{

{
return 0;
}
{
return 0;
}
public abstract String getNombre();
}
class Punto extends Figura{

protected double x;
protected double y;
public Punto(double a, double b)

{
x=a;
y=b;
}
public void setX(double x)

{
this.x=x;
}
public void setY(double y)
{
this.y=y;
}
public double getX()

{
return x;
}
public double getY()

{
return y;
}

{
return "("+x+","+y+")";
}

{
return "Punto";

protected double radio;
public Circulo(double a, double b, double r)

{
super(a,b);
radio=r;
}
public void setRadio(double r)

{
radio=r;
}

{
return radio;
}

{
return Math.PI*Math.pow(radio,2);
}

{
return "Centro "+ super.toString()+", Radio = "+radio;
}

{
return "Circulo";
}
}
class Cilindro extends Circulo{

protected double altura;
public Cilindro(double a,double b, double r, double h)

{
super(a,b,r);
altura=h;
}
public void setAltura(double h)

{
altura=h;
}

{
return altura;
}
{
return 2*super.area()+2*Math.PI*radio*altura;
}

{
return super.area()*altura;
}

{
return super.toString()+ "; Altura = "+altura;
}

{
return "Cilindro";
}
}
public class PruebaFigura{

{
Punto p = new Punto(3,4);
Circulo c = new Circulo(12,20,10);
Cilindro k = new Cilindro (100,100,50,25);
Figura F[] = new Figura[3];
F[0]=p;
F[1]=c;
F[2]=k;
System.out.println(p.getNombre()+" : "+p);
System.out.println(c.getNombre()+" : "+c);
System.out.println(k.getNombre()+" : "+k);
// Procesamos ahora el arreglo de Figuras e imprimimos el
nombre, area y volumen
// de cada objeto
for(int i=0;i<3;i++)
{
System.out.println();
System.out.println(F[i].getNombre()+" : "+F[i]);
System.out.println("Area ="+F[i].area());
System.out.println("Volumen"+F[i].volumen());
System.out.println("=============");
}
}
6.7. INTERFACES
El concepto de interface lleva un paso más adelante la idea de las clases
abstractas. En Java una interface es una clase abstracta pura, es decir
una clase donde todos los métodos son abstractos (no se implementa
ninguno). Permite al diseñador de clases establecer la forma de una
clase (nombres de métodos, listas de argumentos y tipos de retorno,
pero no bloques de código). Una interface puede también contener datos
miembro, pero estos son siempre static y final. Una interface sirve para
establecer un 'protocolo' entre clases.
Para crear una interface, se utiliza la palabra clave interface en lugar de

class. La interface puede definirse public o sin modificador de acceso, y
tiene el mismo significado que para las clases. Todos los métodos que
declara una interface son siempre public.
Para indicar que una clase implementa los métodos de una interface se
utiliza la palabra clave implements. El compilador se encargará de
verificar que la clase efectivamente declare e implemente todos los
métodos de la interface. Una clase puede implementar más de una
interface.
Una interface se declara:
interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}
Por ejemplo:
interface InstrumentoMusical {
void tocar();
void afinar();
String tipoInstrumento();
}
Y una clase que implementa la interface:
class InstrumentoViento extends Object implements

InstrumentoMusical {
void tocar() { . . . };
void afinar() { . . .};
String tipoInstrumento() {}
}
class Guitarra extends InstrumentoViento {

String tipoInstrumento() {
return "Guitarra";
}
}
La clase InstrumentoViento implementa la interface, declarando los

métodos y escribiendo el código correspondiente. Una clase derivada
puede también redefinir si es necesario alguno de los métodos de la
interface.
Referencias a Interfaces
Es posible crear referencias a interfaces, pero las interfaces no pueden
ser instanciadas. Una referencia a una interface puede ser asignada a
cualquier objeto que implemente la interface. Por ejemplo:
InstrumentoMusical instrumento = new Guitarra();
instrumento.play();
System.out.prinln(instrumento.tipoInstrumento());
InstrumentoMusical i2 = new InstrumentoMusical(); //error.No se puede

instanciar
Extensión de interfaces
Las interfaces pueden extender otras interfaces y, a diferencia de las
clases, una interface puede extender más de una interface. La sintaxis
es:
interface nombre_interface extends nombre_interface , . . . {

tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}
Agrupaciones de constantes
Dado que, por definición, todos los datos miembros que se definen en
una interface son static y final, y dado que las interfaces no pueden
instanciarse resultan una buena herramienta para implantar grupos de
constantes. Por ejemplo:
public interface Meses {

int ENERO = 1 , FEBRERO = 2 . . . ;
String [] NOMBRES_MESES = { " " , "Enero" , "Febrero" , . . . };
}
Esto puede usarse simplemente:
System.out.println(Meses.NOMBRES_MESES[ENERO]);
Un ejemplo casi real

El ejemplo mostrado a continuación es una simplificación de como
funciona realmente la gestión de eventos en el sistema gráfico de
usuario soportado por el API de Java (AWT o swing). Se han cambiado
los nombres y se ha simplificado para mostrar un caso real en que el uso
de interfaces resuelve un problema concreto.
Supongamos que tenemos una clase que representa un botón de acción

en un entorno gráfico de usuario (el típico botón de confirmación de una
acción o de cancelación). Esta clase pertenecerá a una amplia jerarquía
de clases y tendrá mecanismos complejos de definición y uso que no
son objeto del ejemplo. Sin embargo podríamos pensar que la clase
Boton tiene miembros como los siguientes.
class Boton extends . . . {

protected int x , y, ancho, alto; // posicion del boton
protected String texto; // texto del boton
Boton(. . .) {
...
}
void dibujar() { . . .}
public void asignarTexto(String t) { . . .}
public String obtenerTexto() { . . .)
...
}
Lo que aquí nos interesa es ver lo que sucede cuando el usuario,

utilizando el ratón pulsa sobre el botón. Supongamos que la clase Boton
tiene un método, de nombre por ejemplo click(), que es invocado por el
gestor de ventanas cuando ha detectado que el usuario ha pulsado el
botón del ratón sobre él. El botón deberá realizar alguna acción como
dibujarse en posición 'pulsado' (si tiene efectos de tres dimensiones) y
además, probablemente, querrá informar a alguien de que se ha
producido la acción del usuario. Es en este mecanismo de 'notificación'
donde entra el concepto de interface. Para ello definimos una interface
Oyente de la siguiente forma:
interface Oyente {
void botonPulsado(Boton b);
}
La interface define un único método botonPulsado. La idea es que este
método sea invocado por la clase Boton cuando el usuario pulse el
botón. Para que esto sea posible en algún momento hay que notificar al
Boton quien es el Oyente que debe ser notificado. La clase Boton
quedaría:
class Boton extends . . . {

...
private Oyente oyente;
void registrarOyente(Oyente o) {
oyente = o;
}
void click() {
...
oyente.botonPulsado(this);
}
}
El método registrarOyente sirve para que alguien pueda 'apuntarse'

como receptor de las acciones del usuario. Obsérvese que existe una
referencia de tipo Oyente. A Boton no le importa que clase va a recibir
su notificación. Simplemente le importa que implante la interface
Oyente para poder invocar el método botonPulsado. En el método click
se invoca este método. En el ejemplo se le pasa como parámetro una
referencia al propio objeto Boton. En la realidad lo que se pasa es un
objeto 'Evento' con información detallada de lo que ha ocurrido.
Con todo esto la clase que utiliza este mecanismo podría tener el
siguiente aspecto:
class miAplicacion extends . . . implements Oyente {

public static main(String [] args) {
new miAplicacion(. . .);
...
}
...
miAplicacion(. . .) {
...
Boton b = new Boton(. . .);
b.registrarOyente(this);
}
...
void botonPulsado(Boton x) {
// procesar click
...
}
}
Obsérvese en el método registrarOyente que se pasa la referencia

thisque en el lado de la clase Boton es recogido como una referencia a la
interface Oyente. Esto es posible porque la clase miAplicacion
implementa la interface Oyente . En términos clásicos de herencia
miAplicacion ES un Oyente .
6.8. PAQUETES
Claúsula Packaged:
Un package es una agrupación de clases afines. Equivale al concepto de

librería existente en otros lenguajes o sistemas. Una clase puede
definirse como perteneciente a un package y puede usar otras clases
definidas en ese o en otros packages.
Los packages delimitan el espacio de nombres (space name). El nombre
de una clase debe ser único dentro del package donde se define. Dos
clases con el mismo nombre en dos packages distintos pueden coexistir
e incluso pueden ser usadas en el mismo programa.
Una clase se declara perteneciente a un package con la clausula

package, cuya sintaxis es:
package nombre_package;
La clausula package debe ser la primera sentencia del archivo fuente.

Cualquier clase declarada en ese archivo pertenece al package indicado.
Por ejemplo, un archivo que contenga las sentencias:
package miPackage;
...
class miClase {
...
declara que la clase miClase pertenece al package miPackage.
La claúsula package es opcional. Si no se utiliza, las clases declaradas

en el archivo fuente no pertenecen a ningún package concreto, sino que
pertenecen a un package por defecto sin nombre.
La agrupación de clases en packages es conveniente desde el punto de

vista organizativo, para mantener bajo una ubicación común clases
relacionadas que cooperan desde algún punto de vista. También resulta
importante por la implicación que los packages tienen en los
modificadores de acceso, que se explican en un capítulo posterior.
Claúsula import
Cuando se referencia cualquier clase dentro de otra se asume, si no se
indica otra cosa, que ésta otra está declarada en el mismo package. Por
ejemplo:
package Geometria;
...
class Circulo {
Punto centro;
...
}
En esta declaración definimos la clase Circulo perteneciente al package

Geometria. Esta clase usa la clase Punto. El compilador y la JVM
asumen que Punto pertenece también al package Geometria, y tal como
está hecha la definición, para que la clase Punto sea accesible
(conocida) por el compilador, es necesario que esté definida en el
mismo package.
Si esto no es así, es necesario hacer accesible el espacio de nombres

donde está definida la clase Punto a nuestra nueva clase. Esto se hace
con la clausula import. Supongamos que la clase Punto estuviera
definida de esta forma:
package GeometriaBase;
class Punto {
int x , y;
}
Entonces, para usar la clase Punto en nuestra clase Circulo deberiamos

poner:
package GeometriaAmpliada;
import GeometriaBase.*;
class Circulo {
Punto centro;
...
}
Con la claúsula import GeometriaBase.*; se hacen accesibles todos los

nombres (todas las clases) declaradas en el package GeometriaBase. Si
sólo se quisiera tener accesible la clase Punto se podría declarar: import
GeometriaBase.Punto;
También es posible hacer accesibles los nombres de un package sin usar

la clausula import calificando completamente los nombres de aquellas
clases pertenecientes a otros packages. Por ejemplo:
package GeometriaAmpliada;
class Circulo {
GeometriaBase.Punto centro;
...
}
Sin embargo si no se usa import es necesario especificar el nombre del

package cada vez que se usa el nombre Punto.
La claúsula import simplemente indica al compilador donde debe buscar

clases adicionales, cuando no pueda encontrarlas en el package actual y
delimita los espacios de nombres y modificadores de acceso. Sin
embargo, no tiene la implicación de 'importar' o copiar código fuente u
objeto alguno. En una clase puede haber tantas sentencias import como
sean necesarias. Las cláusulas import se colocan después de la cláusula
package (si es que existe) y antes de las definiciones de las clases.
Nombres de los packages

Los packages se pueden nombrar usando nombres compuestos
separados por puntos, de forma similar a como se componen las
direcciones URL de Internet. Por ejemplo se puede tener un package de
nombre misPackages.Geometria.Base. Cuando se utiliza esta estructura
se habla de packages y subpackages. En el ejemplo misPackages es el
Package base, Geometria es un subpackage de misPackages y Base es
un subpackage de Geometria.
De esta forma se pueden tener los packages ordenados según una

jerarquía equivalente a un sistema de archivos jerárquico.
El API de java está estructurado de esta forma, con un primer
calificador (java o javax) que indica la base, un segundo calificador
(awt, util, swing, etc.) que indica el grupo funcional de clases y
opcionalmente subpackages en un tercer nivel, dependiendo de la
amplitud del grupo. Cuando se crean packages de usuario no es
recomendable usar nombres de packages que empiecen por java o javax.
Ubicación de packages en el sistema de archivos

Además del significado lógico descrito hasta ahora, los packages
también tienen un significado físico que sirve para almacenar los
módulos ejecutables (ficheros con extensión .class) en el sistema de
archivos del ordenador.
Supongamos que definimos una clase de nombre miClase que pertenece

a un package de nombre misPackages.Geometria.Base. Cuando la JVM
vaya a cargar en memoria miClase buscará el módulo ejecutable (de
nombre miClase.class) en un directorio en la ruta de acceso
misPackages/Geometria/Base. Está ruta deberá existir y estar accesible
a la JVM para que encuentre las clases. En el capítulo siguiente se dan
detalles sobre compilación y ejecución de programas usando el
compilador y la máquina virtural distribuida por SUN Microsystems
(JDK).
Si una clase no pertenece a ningún package (no existe clausula

package ) se asume que pertenece a un package por defecto sin nombre,
y la JVM buscará el archivo .class en el directorio actual.
Para que una clase pueda ser usada fuera del package donde se definió
debe ser declarada con el modificador de acceso public, de la siguiente
forma:
package GeometriaBase;
public class Punto {

int x , y;
}
Si una clase no se declara public sólo puede ser usada por clases que
pertenezcan al mismo package
CAPITULO VII
PROBLEMAS RESUELTOS EN JAVA

7.1. PROBLEMAS RESUELTOS :
ESTRUCTURA SECUENCIAL
Ejemplo 1: Programa que permite mostrar los datos de una persona y

su pago.
import java.io.*;
public class ejercicio32
{
public static void main(String[] args) throws IOException
{ String nom,ap;
double pm,pmt,pt;
BufferedReader leer = new BufferedReader(new
System.out.println("ingrese su nombre");
nom=(leer.readLine());
System.out.println("ingrese sus apellidos");
ap=(leer.readLine());
System.out.println("ingrese el pago mensual");
pm=Double.parseDouble(leer.readLine());
System.out.println("ingrese el pago de la matricula");
pmt=Double.parseDouble(leer.readLine());
pt=pm+pmt;
System.out.println("su nombre es:"+nom);
System.out.println("sus apellidos son:"+ap);
System.out.println("el pago total es:"+pt);
}
}
Ejemplo 2: Programa que permite calcular el producto de un numero
ingresado por teclado.
import java.io.*;
public class Ejercicio02
{ public static void main(String Args[])throws IOException
{double num,res=0;
BufferedReader in = new BufferedReader(new
System.out.println("Ingrese un numero:");
num=Double.parseDouble(in.readLine());
res=num*2*25;
System.out.print("El el resultado de multiplicar por 25 y duplicar
es:" + res);
}
}
Ejemplo 3: Programa que permite calcular el perimetro y area de un

rectangulo.
import java.io.*;
{ double la,lb,p=0,area=0;
BufferedReader leer= new BufferedReader(new
System.out.println("Ingrese un lado:");
la=Double.parseDouble(leer.readLine());
System.out.println("Ingrese el otro lado:");
lb=Double.parseDouble(leer.readLine());
p = la*2 + lb*2;
area=la*lb;
System.out.println("El perimetro del rectangulo es:" + p);
System.out.println("El area del rectangulo es:" + area); }
}
Ejemplo 3: Programa que permite convertir metros en pies y pulgadas.
import java.io.*;
{double me,pies=0,pul=0;
System.out.println("Ingrese la cantidad en metros:");
me= Double.parseDouble(in.readLine());
pul=me*39.37;
pies=pul*12;
System.out.println("su convercion en pies es:"+pies+"pies");
System.out.println("su convercion en pulgadas
es:"+pul+"pulgadas");
}
}
Ejemplo 4: Programa que permite calcular la hipotenusa de un

triangulo.
import java.io.*;
{int Co,Ca;
double h,parcial;
System.out.println("Ingrese la longitud del primer cateto:");
Co=Integer.parseInt(leer.readLine());
System.out.println("Ingrese la longitud del segundo cateto:");
Ca=Integer.parseInt(leer.readLine());
parcial= Co*Co+Ca*Ca;
h= Math.pow(parcial, 0.5);
System.out.print("LA hipotenusa es:"+h);
}
}
Ejemplo 5: Programa que permite calcular el tiempo de demora de 3
tipos de examenes.
import java.io.*;
{public static void main(String Args[])throws IOException
{int EA,EB,EC;
int TM=0,h=0,min=0;
System.out.println("Ingrese la cantidad de Examenes del tipo A:");
EA=Integer.parseInt(leer.readLine());
System.out.println("Ingrese la cantidad de Examenes del tipo B:");
EB=Integer.parseInt(leer.readLine());
System.out.println("Ingrese la cantidad de Examenes del tipo C:");
EC=Integer.parseInt(leer.readLine());
TM=EA*5+EB*8+EC*6;
h= TM/60;
min= TM/60;
System.out.print("Se va a demorar: "+h+" horas y "+min+"
minutos.");
}
}
Ejemplo 6: Programa que permite calcular el promedio de varones y

mujeres.
import java.io.*;
{double total=0,PV=0,PM=0,V,M;
System.out.println("Ingrese la cantidad de varones:");
V=Double.parseDouble(in.readLine());
System.out.println("Ingrese la cantidad de mujeres:");
M=Double.parseDouble(in.readLine());
total = V +M;
PV=(V*total)/100;
PM=(M*total)/100;
System.out.println("El porcentaje de varones es:" +PV+"%");

System.out.println("El porcentaje de mujeres es:" +PM+"%");
}
}
Ejemplo 7: Programa que permite calcular el tiempo que tarda en dar

dos vueltas un automovil.
import java.io.*;
{double v,r,l=0,t=0;
System.out.println("Ingrese la velocidad en m/s:");
v= Double.parseDouble(leer.readLine());
System.out.println("Ingrese el radio de la pista: ");
r= Double.parseDouble(leer.readLine());
l=2*3.1416*r;
t=l/v;
System.out.println("el tiempo que tarda de dar 2 vueltas es
de:"+t+"segundos.");
}
}
Ejemplo 8: Programa que permite convertir una temperatura en grados
celcius a Fahrenheit.
import java.io.*;
{double C,F;
BufferedReader leer=new BufferedReader(new
System.out.println("Ingrese la temperatura en Celcius");
C= Double.parseDouble(leer.readLine());
F=(9*C)/5 + 32;
System.out.println("La temperatura en Fahrenheit es: " + F);
}
}
Ejemplo 9: Programa que permite calcular la suma de dos numeros

definidos como constante.
import java.io.*;
public class ejemplo1
{
public static void main(String[] args)throws IOException
{
double num1=20;
double num2=30;
System.out.print("La suma es :"+(num1+num2));
}
}
Ejemplo 10: Programa que permite calcular la suma de dos numeros
ingresados por teclado.
import java.io.*;
{
{
double num1, num2, suma=0;
System.out.print("Ingrese los valores");
System.out.print("Ingrese el primer valor :");
num1=Double.parseDouble(leer.readLine());
System.out.print("Ingrese el segundo valor :");
num2=Double.parseDouble(leer.readLine());
suma=num1+num2;
System.out.print("La suma es:"+suma);
}
}
ESTRUCTURA CONDICIONAL SIMPLE (IF)
Ejemplo 11: Programa que permite calcular si un numero es positivo,

negativo o cero.
import java.io.*;
{
{
int num1;
num1 =Integer.parseInt(leer.readLine());
if (num1>0)
{
System.out.println(num1 + " es positivo");
}
else
if (num1<0)
{
System.out.println(num1+ " es negativo");
}
else
if (num1==0)
{
System.out.println(num1 + " es cero");
}
}
}
Ejemplo 12: Programa que permite calcular las operaciones basicas de
resta, suma, multiplicación y division de dos numeros ingresados por
teclado.
import java.io.*;
{
public static void main (String[] args) throws IOException
{ int x,y;
int res=0,sum=0,mult=0,div=0;
BufferedReader leer=new BufferedReader(new
System.out.println("ingrese el primer valor");
x=Integer.parseInt(leer.readLine());
System.out.println("ingrese el segundo valor");
y=Integer.parseInt(leer.readLine());
res=x-y;
sum=x+y;
mult=x*y;
if(y!=0)
{
div=x/y;
}
else
{
System.out.println("no existe divicion entre cero");
}
System.out.println("la resta es:"+ res);
System.out.println("la suma es :"+ sum);
System.out.println("la multiplicacion es :"+mult);
System.out.println("la divicion es:"+div);
}
}
Ejemplo 13: Programa que permite calcular el costo de una llamada
telefonica.
import java.io.*;
{
{
double min;
double cll=0;
int c1=5;
int c2=3;
System.out.println("ingresar los minutos consumidos");
min =Double.parseDouble(leer.readLine());
if (min>0 && min<=3)
{
cll=min*c1;
}
else
{
cll=(3*c1)+((min-3)*c2);
}
System.out.println("elcosto de la llamada es : " + cll);
}
}
Ejemplo 14: Programa que permite calcular la condicion de estudiante
de acuerdo a sus tres examenes ingresados..
import java.io.*;
{ public static void main(String[] args) throws IOException
{ double EX1,EX2,EX3,PF=0;
System.out.println("ingrese la nota del primer examen:");
EX1=Double.parseDouble(leer.readLine());
System.out.println("ingrese la nota del segundo examen:");
System.out.println("ingrese la nota del tercer examen:");
PF=(EX1+EX2+EX3)/3;
if (PF>=0 && PF<=69)
{
System.out.println(PF+":reprobado.");
}
if (PF>=70 && PF<=79)
{
System.out.println(PF+":hay que mejorar.");
}
if (PF>=80 && PF<=89)
{
System.out.println(PF+":bien.");
}
if (PF>=90 && PF<=99)
{
System.out.println(PF+":muy bien.");
}
if (PF==100)
{
System.out.println(PF+":excelente.");
}
}
}
Ejemplo 15: Programa que permite mostrar el tipo de triangulo que se
forma según valores ingresados de sus tres lados.
import java.io.*;
{
{ int A,B,C;
System.out.println("ingrese el lado mayor");
A=Integer.parseInt(leer.readLine());
System.out.println("ingrese primer lado");
B=Integer.parseInt(leer.readLine());
System.out.println("ingrese segundo lado");
C=Integer.parseInt(leer.readLine());
if (A>=(B+C))
{
System.out.println("no se forma un triangulo");
}
if ((A^2)==((B^2)+(C^2)))
{
System.out.println("se forma un triangulo rectangulo");
}
if ((A^2)>((B^2)+(C^2)))
{
System.out.println("se forma un triangulo obtusangulo");
}
if ((A^2)<((B^2)+(C^2)))
{
System.out.println("se forma un triangulo acutangulo");
}
}
}
Ejemplo 16: Programa que permite mostrar la condicion que cumple
una persona según su edad ingresada.
import java.io.*;
{
{ int edad;
System.out.println("ingrese su edad");
edad=Integer.parseInt(leer.readLine());
if (edad>18)
{
System.out.println("usted es todo un joven , y su edad
es:"+edad);
}
else
{
System.out.println("usted es aun un adolescente y su edad
es:"+edad);
}
}
}
Ejemplo 17: Programa que permite ingresar n numeros y muestra como

resultado la cantidad de numeros pares y cantidad de numeros impares.
import java.io.*;
public class caso3
{
public static void main(String[] args)throws IOException
{double c,i,num,par=0,impar=0;
//Creando el metodo para el ingreso de datos
BufferedReader l = new BufferedReader(new

System.out.println("uso de la sentencia if y for");
System.out.println("calculando numeros pares e impares");
System.out.println("ingrese cantidad de valores ha procesar :");
c=Double.parseDouble(l.readLine());
for(i=1;i<=c;i++)
{System.out.print("ingrese valor:"+i);
num=Double.parseDouble(l.readLine());
if(num%2==0)
par++;
else
impar++;
}
System.out.println("la cantidad de numeros pares="+par);
System.out.println("la cantidad de numeros impares="+impar);
}
}
Ejemplo 18: Programa que permite calcular si un numero ingresado es

par, utilizando metodos.
import java.io.*;
{public static void par(int num)
{
if((num%2)==0)
{System.out.println("El numero es par");
}
else
{System.out.println("El numero es impar");
}
}
{
int numero;
BufferedReader leer=new BufferedReader (new
System.out.println("Ingrese un numero :");
numero =Integer.parseInt(leer.readLine());
par(numero);
}
}
Ejemplo 19: Programa que permite calcular el mayor de dos numeros

si existe, caso contrario mostrara un mensaje que los numeros son
iguales.
import java.io.*;
{
{
int a,b;
System.out.println("ingrese 2 numeros");
a =Integer.parseInt(leer.readLine());
b =Integer.parseInt(leer.readLine());
if (a>b)
{
System.out.println(a+"es mayor");
}
else
if (b>a)
{
System.out.println(b+"es mayor");
}
else
if (a==b)
{
System.out.println(a+"y"+b+"son iguales");
}
}
}
par, n cantidad de veces y utilizando metodos.
import java.io.*;
{
public static void par(int num)
{
if((num%2)==0)
{System.out.println("El numero es par");
}
else
{System.out.println("El numero es impar");
}

{
int numero, num;
System.out.print("Ingrese la cantidad de numeros a leer:");
num=Integer.parseInt(leer.readLine());
for(int x=1;x<=num;x++)
{System.out.print("Ingrese un numero :");
numero =Integer.parseInt(leer.readLine());
par(numero);
}
}
}
par, n cantidad de veces y utilizando metodos.
import java.io.*;
{double v,r,l=0,t=0;
System.out.println("Ingrese la velocidad en m/s:");
v= Double.parseDouble(leer.readLine());
System.out.println("Ingrese el radio de la pista: ");
r= Double.parseDouble(leer.readLine());
l=2*3.1416*r;
t=l/v;
System.out.println("el tiempo que tarda de dar 2 vueltas es
de:"+t+"segundos.");
}
}
Ejemplo 22: Programa que permite ingresar 5 numeros y muestra como

resultado el numero mayor y numero menor
import javax.swing.JOptionPane;
public class caso4
{ public static void main (String[] args)
{ String b;
double n1,num,i, may = 0, men= 0;
for ( i=1; i<=5; i++)

{ b=JOptionPane.showInputDialog("Ingresa Valores:"+ i);
num = Double.parseDouble(b);
if (i == 1)
{ may = num;
men= num;
}
else
if (num > may)
{may = num;
}
else
if (num<men)
{men = num;
}
}
JOptionPane.showMessageDialog(null,"EL numero mayor es "+ may);

JOptionPane.showMessageDialog(null,"EL numero menor es"+ men);
}
}
Ejemplo 23: Programa que permite sumar dos numeros
import javax.swing.JOptionPane;
public class SumarNumeros
{
public static void main( String args[] )
{ String strNumero1;
String strNumero2;
int intNumero1;
int intNumero2;
int suma;
strNumero1=JOptionPane.showInputDialog("Ingrese el entero 1" );
strNumero2= JOptionPane.showInputDialog("Ingrese el entero2" );
intNumero1 = Integer.parseInt( strNumero1 );
intNumero2 = Integer.parseInt( strNumero2 );
suma = intNumero1 + intNumero2;
JOptionPane.showMessageDialog( null, "La suma es " + suma,
"Resultado", JOptionPane.PLAIN_MESSAGE );
System.exit( 0 );
}
}
Ejemplo 24: Programa que permite ingresar tu edad y calcula el año de
su nacimiento
import java.io.*;
public class p
{ public static void main(String[] args) throws IOException
{ InputStreamReader reader = new InputStreamReader(System.in);
BufferedReader input = new BufferedReader(reader);
System.out.print("Escribe tu edad: ");
String text = input.readLine();
int edad = new Integer(text).intValue();
System.out.println("Tu tienes " + edad + " años, hoy,");
int año = 2008 - edad;
System.out.println("por tanto posiblemente naciste en " + año);
}
}
ESTRUCTURA SELECTIVA MULTIPLE (CASE)
Ejemplo 25: Programa que nos permite mostrar una pregunta con 3
alternativas, al elegir uno de ellos nos muestra si la respuesta es correcta
o no, si no acertamos nos pide que sigamos intentando hasta elgir el
correcto
import java.io.*;
import java.util.*;
public class gg
{
static BufferedReader entrada = new BufferedReader(new
static String respuesta;
static char opc;
static void pregunta1() throws IOException
{
opc=0;
System.out.println("1ra Pregunta:");
System.out.println("¿Cual es el planeta mas cercano a la tierra?");
System.out.println("A)Mercurio");
System.out.println("B)Tierra");
System.out.println("C)Pluton");
respuesta=entrada.readLine();
respuesta=respuesta.toUpperCase();
opc=respuesta.charAt(0);
if(opc=='A')
System.out.println("Respuesta Correcta :D");
else
System.out.println("Respuesta incorrecta, intenta de nuevo");
}
{
Random rnd=new Random();
int i;
i=rnd.nextInt(5);
System.out.println(i);
switch(i)
{
case 0:
while(opc!='A')
pregunta1();
break;
case 1:
System.out.println("Numero 1");
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
}
}
}
Ejemplo 26: Programa que nos permite visualizar un día de la semana

en función al numero que se consigna (0 a 7); si se escribe otro numero
nos indicará que ingresemos un numero correcto
import java.io.*;
public class case3
{
{
int num1;
String dia="";
System.out.println("Ingrese un numero ");
num1=Integer.parseInt(leer.readLine());
switch(num1)
{
case 1:
dia="Lunes";
break;
case 2:
dia="Martes";
break;
case 3:
dia="Miercoles";
break;
case 4:
dia="Jueves";
break;
case 5:
dia="Viernes";
break;
case 6:
dia="Sabado";
break;
case 7:
dia="Domingo";
break;
default:
dia="Ingrese un numero correcto";
break;
}
System.out.println("El dia es >"+dia);
}
ESTRUCTURA REPETITIVA FOR
Ejemplo 27: Programa que nos permite calcular el factorial de un

numero.
import java.io.*;
{ // Creates a new instance of ejercicio9
public static void fac(int num)

{
int a=1;
for(int y=1;y<=num;y++)
{a*=y;}
System.out.print("El factorial de "+num+" es "+a);
}
{int numero, num;
System.out.print("Ingrese el valor:");
num=Integer.parseInt(leer.readLine());
fac(num);
}
}
Ejemplo 28: Programa que nos permite realizar el factorial de un

numero utilizando try.
import java.io.*;
class case5
{
public static void main(String[] args) {
try{
BufferedReader object = new BufferedReader(new
System.out.println("enter the number");
int a= Integer.parseInt(object.readLine());
int fact= 1;
System.out.println("Factorial of " +a+ ":");
for (int i= 1; i<=a; i++){
fact=fact*i;
}
System.out.println(fact);
}
catch (Exception e){}
}
}
ESTRUCTURA REPETITIVA WHILE
Ejemplo 29: Programa que calcula la media, a medida que se van

incorporando datos.
import java.io.*;
class media
{
public static void main(String Arg[ ]) throws IOException
{
double media = 0.0;
int n = 0;
int elementos;
double num;

System.out.print("Ingrese numero de elementos a ingresar : ");

elementos = Integer.parseInt(in.readLine( ));
while (n < elementos)

{
System.out.print("\nIngrese numero : ");
num = Double.parseDouble(in.readLine( ));
media = (media * n + num) / (double) (n + 1);
/* Redondea a dos decimales */
media = Math.round(media * 100.0) / 100.0;

System.out.println("media actual : " + media);
n++;
}
System.out.println("\nMedia final : " + media );

}
}
Ejemplo 30: Programa que permite mostrar en pantalla todos los #s
mayores e iguales de 20 hasta el 100 de 2 en 2, utilizando clases.
class pares
{
public static void main(String arg[ ])
{ int num = 20;
while (num < 101)
{if (num % 2 == 0)
{ System.out.println(num);
}
num = num + 1;
}
}
}
Ejemplo 31: Programa que permite escribir en pantalla, la secuencia de

números del 50 al 100
public class SecNum

{
public static void main(String arg[ ])
{
int num = 50;
while(num < 101)
{
System.out.println(num);
num = num + 1;
}
}
}
Ejemplo 32: Programa que permite convertir un numero constante en

binario
import java.io.*;
public class binario{
public static void main(String args[]){
int decimal = 25222;
String binario = "";

while ( decimal > 0 ) {
binario = decimal % 2 + binario;
decimal /= 2;
}
System.out.println(binario);
}
}
Ejemplo 33: Programa que nos permite sumar los numeros divisibles
por dos, del numero ingresado
import java.io.*;
class while1
{
public static void main(String Arg[ ]) throws IOException
{
int i = 1;
int sum = 0;
int num;

System.out.print("Ingrese numero : ");

num = Integer.parseInt(in.readLine( ));
while (i <= num)

{
if (i % 2 == 0)
{sum += i;
}
i++;
}
System.out.println("sumatoria : " + sum );

}
}
Ejemplo 34: Programa que nos permite sumar los n primeros n enteros,
donde n es un numero ingresado por el usuario
import java.io.*;
public class while3
{ public static void main(String [] args)
{ int number;
int sum;
int num;
System.out.print("Por favor ingrese un numero: ");
number=keyboard.readInt();
//inicializar en 0
sum = 0;
num = number;
//calcular la suma
while(num > 0)
sum += num--;
//Mostrar la respuesta
System.out.println("La suma de suma de los primeros " + number
+" enteros es " + sum + ".");
}
}
Ejemplo 35: Programa que nos permite calcular la suma de los 10

primero numeros enteros
public class while4

{ public static void main(String args[])
{ int sum = 0;
int i = 1;
// Calculando la suma de los numeros enteros entre 1 y 10
while ( i <= 10 )
{ sum = sum + i;
i++;
}
System.out.println("The sum is: " + sum);
}
}
ARREGLOS UNIDIMENCIONALES:
Ejemplo 36: Programa que nos permite calcular la suma e dos arreglos
import java.io.*;
public class P2
{
public static void main(String Nubito[])throws IOException{
double a[]=new double [5];

double b[]=new double [5];
double c[]=new double [5];
BufferedReader dat=new BufferedReader(new
System.out.println("Ingrese los 5 elementos del vector A ");
{
System.out.print("Numero "+(i+1)+": ");
a[i]=Double.parseDouble(dat.readLine());
}
System.out.println("Ingrese los 45 elementos del vector B ");
{ System.out.print("Numero"+(i+1)+": ");
b[i]=Double.parseDouble(dat.readLine());
}
{
c[i]=a[i]+b[i];
}
{
System.out.println("la suma es :"+c[i]);
}
}
}
Ejemplo 37: Programa que nos permite calcular la suma de datos en un
arreglo, utilizando metodos.
import java.io.*;
public class metodoMatriz
{
public static void opera(int m[])
{ int sum=0;
for(int x=0;x<m.length;x++)
{sum=sum+m[x];
}
System.out.println("La suma de los valores es "+sum);
}
public static void main(String xp[])throws IOException

{
int mat[]=new int [5];
BufferedReader leer = new BufferedReader (new
for(int y=0;y<mat.length;y++)
{System.out.print("Ingrese un numero : ");
mat[y]=Integer.parseInt(leer.readLine());
}
opera(mat);
}
}
Ejemplo 38: Programa que nos permite calcular el numero mayor y su
posición.
import java.io.*;
public class P3
{
public static void main(String Nubito[])throws IOException
{
double may=0;
double pos=0;
double m[]=new double [5];
System.out.println("Ingrese los 5 elementos del vector ");
{
System.out.print("Elemento "+(i+1)+": ");
m[i]=Double.parseDouble(dat.readLine());
if(m[i]>may)
{
may=m[i];
pos=i;
}
}
System.out.println("El numero mayor es "+may);
System.out.println("En la posicion:" +pos);
}
}
Ejemplo 39: Programa que nos permite calcular el cuadrado de los
valores ingresados en un arreglo.
import java.io.*;
public class P4
{
{
double n[]=new double [5];
System.out.println("Ingrese los 500 numeros del vector ");
{
n[i]=m[i]*m[i];
}
System.out.println("Los valores originales son : ");
{
System.out.println(+m[i]);
}
System.out.println("Los valores al cuadrado son : ");
{
System.out.println(+n[i]);
}
}
}
Ejemplo 40: Programa que nos permite calcular la suma de numeros
iguales a cero, la cantidad de numeros positivos, la cantidad de numeros
negativos, la suma de los numeros positivos y la suma de numeros
negativos.
import java.io.*;
public class P5
{
{
int pos=0,neg=0,c=0;
double sump=0,sumn=0;
{
n[i]=Double.parseDouble(dat.readLine());
if(n[i]==0)
{ c=c+1;
}
if(n[i]>0)
{ pos=pos+1;
sump=sump+n[i];
}
if(n[i]<0)
{ neg=neg+1;
sumn=sumn+n[i];
}
}
System.out.println("Los numeros iguales a cero son : "+c);
System.out.println("Los numeros positivos son : "+pos);
System.out.println("Los numeros negativos son : "+neg);
System.out.println("La suma de los positivos es : "+sump);
System.out.println("La suma de los negativos es : "+sumn);
}
}
Ejemplo 41: Programa que nos permite mostrar los datos ingresados en
forma invertida.
import java.io.*;
public class P6
{
{
double inv[]=new double [5];
int x=0;
{
x=5-(i+1);
inv[x]=m[i];
}
System.out.println("El vector resultantes es ");
{
System.out.println(+inv[i]);
}
}
}
Ejemplo 42: Programa que nos permite calcular la suma de dos arreglos
de igual cantidad de datos.
import java.io.*;
{
{
double a[]=new double [10];
double dato;
System.out.println("Ingresa los datos a los arreglo");
for(int i=0;i<a.length;i++)
{System.out.println("Ingrese A["+(i+1)+"] :");
dato=Double.parseDouble(leer.readLine());
a[i]=dato;
}
{System.out.println("Ingrese B["+(i+1)+"] :");
b[i]=dato;
}
{c[i]=a[i]+b[i]; }
{System.out.println("la suma del arreglo
A["+(i+1)+"]+B["+(i+1)+"] es "+c[i]);
}
}
}
Ejemplo 43: Programa que nos permite mostrar, si los datos de dos
vectores(arreglos), son iguales.
import java.io.*;
public class P7
{ public static void main(String Nubito[])throws IOException
{
int x=0;
System.out.println("Ingrese los 5 elementos del vector M ");
{
}
System.out.println("Ingrese los 5 elementos del vector N ");
{
}
{
if(m[i]==n[i])
{x=x+1;}
}
if(x==5)
{System.out.println("Los vectores son Iguales"); }
else
{
System.out.println("Los vectores son Desiguales");
}
}
}
Ejemplo 44: Programa que nos permite buscar un numero en el arreglo
import java.io.*;
public class P9
{
{ double n[]=new double [8];
double x=0;
int p=0;
System.out.println("Ingrese los 80 elementos del vector ");
{ System.out.print("Elemento "+(i+1)+": ");
}
System.out.println("Ingrese el numero a buscar : ");
x=Double.parseDouble(dat.readLine());
{if(n[i]==x)
{ p=i+1;
}
}
if(p>0)
{System.out.println("El numero se encuentra en la posicion:" +p);
}
else
{
System.out.println("No se encontro el numero");
}
}
}
Ejemplo 45: Programa que nos permite cacular el factorial de n
numeros ingresados en un arreglo.
import java.io.*;
{
{double a[]=new double [3];
double dato;
double facnum;
int num=1,fac, x=0;
System.out.println("Ingresa los datos a los arreglo");
{System.out.print("Ingrese A["+(i+1)+"] :");
a[i]=dato;
}
{facnum=a[i];
fac=1;
for(int j=1;j<=facnum;j++)
{fac=fac*j;
}
System.out.print(fac);
b[i]=fac;
fac=0;
}
{System.out.println("Ingrese B["+(i)+"] :"+b[i]);
}
}
}
Ejemplo 46: Programa que nos permite calcular el producto de dos
arreglos con cantidad de datos iguales.
import java.io.*;
public class P10
{ public static void main(String nubito[])throws IOException
{ double a[]=new double [20];
int x=0;
System.out.println("Ingrese los 20 numeros del vector A");
{ System.out.print("Numero "+(i+1)+": ");
a[i]=Double.parseDouble(dat.readLine());
}
System.out.println("Ingrese los 20 numeros del vector B");
{System.out.print("Numero "+(i+1)+": ");
b[i]=Double.parseDouble(dat.readLine());
}
{x=20-(i+1);
c[i]=a[i]*b[x];
}
{System.out.println("La multiplicacion es: "+c[i]);
}
}
}
ARREGLOS BIDIMENCIONALES:
Ejemplo 47: Programa que nos permite calcular la suma de un arreglo

bidimensional.
import java.io.*;
public class P12
{ double m[][]=new double [5][6];
double suma=0;
System.out.println("Ingrese los valores de la matriz");
{ for(int j=0;j<6;j++)
{System.out.print("Ingrese el un numero : ");
m[i][j]=Double.parseDouble(dat.readLine());
suma=suma+m[i][j];
}
}
System.out.println("la suma es :"+suma);
}
}
Ejemplo 48: Programa que nos permite calcular el numero mayor y su

posición en un arreglo bidimensional.
import java.io.*;
public class P13
double may=0;
int posi=0,posj=0;
{System.out.print("Ingrese un numero: ");
m[i]
[j]=Double.parseDouble(dat.readLine());
if(m[i][j]>may)
{may=m[i][j];
posi=i+1;
posj=j+1;
}
}
}
System.out.println("El numero mayor es "+may);
System.out.println("En la posicion ("+posi+","+posj+")");
}
}
Ejemplo 49: Programa que nos permite calcular la suma de una

columna y fila en un arreglo bidimensional.
import java.io.*;
public class P14
{ public static void main(String args[])throws IOException
{BufferedReader VTL=new BufferedReader(new
double m[][]=new double [5][5];
double d[]=new double [5];
double sc[]=new double[5];
double sf[]=new double[5];
for(int f=0;f<5;f++)
{ for(int c=0;c<5;c++)
{System.out.print("Ingrese el valor de la posicion
("+(f+1)+","+(c+1)+" : ");
m[f][c]=Double.parseDouble(VTL.readLine());
}
}
for(int c=0;c<5;c++)
{ for(int f=0;f<5;f++)
{sc[c]=sc[c]+m[f][c];
}
}
{sf[f]=sf[f]+m[f][c];
}
}
{System.out.println("La suma de la fila "+f+" es "+sf[f]);
}
{System.out.println("La suma de la columna "+c+" es "+sc[c]);
}
}
}
Ejemplo 50: Programa que nos permite calcular la columna que tiene
mayor suma.
import java.io.*;
public class P15
double sc[]=new double [5];
double may=0;
int c=0;
{for(int j=0;j<5;j++)
{ System.out.print("Ingrese un numero : ");
}
}
for(int j=0;j<5;j++)
{ for(int i=0;i<5;i++)
{ sc[j]=sc[j]+m[i][j];
}
if(sc[j]>may)
{may=sc[j];
c=j;
}
}
System.out.println("La columna que tiene la mayor suma es "+c);
System.out.println("La suma es "+may);
}
}
Ejemplo 51: Programa que nos permite mostrar la diagonal de una

matriz.
import java.io.*;
public class P16
{public static void main(String Nubito[])throws IOException
("+(i+1)+","+(j+1)+" : ");
if(i==j)
{d[i]=m[i][j];}
}
}
System.out.println("La diagonal principal es ");
{System.out.println(""+d[i]);
}
}
}
Ejemplo 52: Programa que nos permite calcular la suma en una serie
fibonacci
import java.io.*;
public class pre_11
{
public static void main (String args [])
{
int x, y;
String leer;
System.out.println("SERIE FIBONACCI");
long Fib[]=new long[50];
Fib[0]=0;
Fib[1]=1;
Fib[2]=Fib[0]+Fib[1];
y=3;
while (y < 50)
{
Fib[y]= Fib[y-1] + Fib[y-2];
y++;
}
for(x=0;x<50;x++)
{
System.out.println(Fib[x]);
}
}
}
Ejemplo 53: Programa que nos permite calcular la suma de una fila y
columna
import java.io.*;
public class preg_19
{ public static void main(String args[])throws IOException
{
BufferedReader VTL=new BufferedReader(new
double m[][]=new double [5][5];
double suma[]=new double[5];
double sf[]=new double[10];
{ for(int c=0;c<5;c++)
("+(f+1)+","+(c+1)+" : ");
m[f][c]=Double.parseDouble(VTL.readLine());
}
}
{suma[f]=suma[f]+m[f][c];
}
}
{ suma[c]=suma[c]+m[f][c];
}
}
{ System.out.println("La suma de la fila "+f+" es "+suma[f]);
}
{System.out.println("La suma de la columna "+c+" es
"+suma[c]); }
}
}
Ejemplo 54: Programa que nos permite calcular la suma transversal en

una matriz bidimensional.
import java.io.*;
{
{
double mat[][] = new double [2][2];
double suma=0;
System.out.println("Ingrese los valores a la matriz");
{for(int c=0;c<2;c++)
{System.out.print("Ingrese ["+f+"] - ["+c+"] :");
mat[f][c]=Double.parseDouble(leer.readLine());
}
}
{System.out.println("\n");
{ if(f==c)
{ suma=suma+mat[f][c];
}
}
}
{System.out.println("\n");
{System.out.print("\t\t"+Math.round(mat[f][c]));
}
}
System.out.println("\n");
System.out.print("La suma de su transversal es:"+suma);
}
}
Ejemplo 55: Programa que nos permite calcular la suma una matriz
bidimensional.
import java.io.*;
public class metodoMatriz_2
{ public static void opera(int m1[],int m2[])
{int mul=0;
for(int x=0;x<m1.length;x++)
{mul=m1[x]+m2[x];
System.out.println("La suma de los valores es "+mul);
}
}
public static void main(String xp[])throws IOException

{
int tam;
int a[];
int b[];
BufferedReader leer = new BufferedReader (new
System.out.println("Ingrese el tamaño del arreglo :");
tam=Integer.parseInt(leer.readLine());
a=new int [tam];
b=new int [tam];
for(int y=0;y<a.length;y++)
{System.out.print("Ingrese un numero arreglo A : ");
a[y]=Integer.parseInt(leer.readLine());
}
for(int y=0;y<b.length;y++)
{System.out.print("Ingrese un numero arreglo B : ");
b[y]=Integer.parseInt(leer.readLine());
}
opera(a,b);
}
}
Ejemplo 56: Programa que nos permite calcular las posibles posiciones
de un alfil en un juego de ajedrez.
import java.io.*;
import java.lang.Math;
public class Ajedrezbidimensional {
public static void main(String args[]) {
int fila, columna;
int fila1,columna1;
int fila2,columna2;
int fila3,columna3;
int fila4,columna4;
try{
System.out.println("INGRESE LA POSICION
INICIAL DEL ALFIL(FILA Y
COLUMNA)");
BufferedReader entrada=new
BufferedReader(new
System.out.println("INGRESE LA FILA");
fila=Integer.parseInt(entrada.readLine());
System.out.println("INGRESE LA
COLUMNA");
columna=Integer.parseInt(entrada.readLine());
System.out.println("LISTA DE POSICIONES
POSIBLES DEL ALFIL ");
System.out.println("");
fila1=fila;
columna1=columna;
while ((fila1<8) && (columna1<8))

{
fila1=fila1+1;
columna1=columna1+1;
System.out.println(" FILA "+fila1+"

COLUMNA "+columna1);}
fila2=fila;
columna2=columna;
while ((fila2>1) && (columna2>1))

{
fila2=fila2-1;
columna2=columna2-1;
fila3=fila;
columna3=columna;
while ((fila3<8) && (columna3>1))

{
fila3=fila3+1;
columna3=columna3-1;
fila4=fila;
columna4=columna;
while ((fila4>1) && (columna4<8))

{
fila4=fila4-1;
columna4=columna4+1;
}catch(IOException e){}
}
}
BIBLIOGRAFIA
 BROOKSHEAR GLENN J.: ¨ Introducción a las Ciencias de la

Computación - Ed. Asdison Wesley Americana. 1995
 BRAUNSTEIN - GIOIA: " Introducción a la Programación y a
las Estructuras de Datos”. Ed. Eudeba. Bs. As. 2003.
 AHO - HOPCROFT y ULLMAN: " Estructuras de datos y
algoritmos”. Ed. Adisson Wesley Iberoamericana. México. 2003.
 BRAUNSTEIN-GIOIA: "Introducción a la programación y a
las estructuras de datos". Ed. Eudeba.
 SCHILDT, HERBERT & HOLMES, JAMES: “ El arte de
programar en Java”. Ed. Prentice Hall, México 2004
 ADAM DROZDEK: “Estructura de datos y algoritmos en
Java”. Ed. Prentice Hall, México 2007.
 SCHILDT, HERBERT: “ Fndamentos de Java” ”. Ed. Prentice
Hall, México 2006.
Direcciones Electrónicas
 http://todojava.awardspace.com/manuales-java.html
 http://www.webtaller.com/manual-java/indice_manual_java.php
 http://www.manual-java.com/

Manual de Java

Cargado por

Copyright:

Formatos disponibles

Manual de Java

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de Java

Cargado por

Copyright:

Formatos disponibles

Algoritmia

1.1. INTRODUCCIÓN Y MOTIVACIÓN

1.2. FASES EN LA RESOLUCIÓN DE PROBLEMAS

 Análisis del problema

Constituye el ciclo de vida del software y sus características más

 Análisis. El problema se analiza teniendo presente

 Preciso (indica el orden de realización en cada paso),

Un algoritmo debe producir un resultado en un tiempo finito. Los

1.2.1. Análisis del Problema

Análisis Diseño Resolución del

Figura 1. Análisis del problema

Para poder identificar y definir bien un problema es conveniente

D= Costo – valor de recuperación

D = 1.800.00 – 120.00 = 1,680.00 = 280.00

Proceso cálculo de la depreciación acumulada cada año

1.2.2. Diseño del Algoritmo

En la etapa de análisis del proceso de programación se determina

1.2.3. Herramientas de Programación

Las dos herramientas más utilizadas comúnmente para diseñar

El pseudocódigo es una herramienta de programación en la que

1.2.4. Herramientas de Programación

1.2.5. Compilación y Ejecución de un Programa

Figura 3. Fases de la compilación/ejecución de un programa:

1.2.6. Verificación y Depuración de un Programa

La verificación o compilación de un programa es el proceso de

1.2.7. Documentación y Mantenimiento

La documentación de un problema consta de las descripciones de

1.3. PROGRAMACION MODULAR

La programación modular es uno de los métodos de diseño más flexible

Modulo Modulo Modulo Modulo

Figura 4. Programación Modular

1.4. PROGRAMACION ESTRUCTURADA

Los términos programación modular, programación descendente y

1.4.1. Recursos Abstractos

La programación estructurada se auxilia de los recursos abstractos

1.4.2. Diseño Descendente (top-down)

El diseño descendente (top-down) es el proceso mediante el cual

Nivel n: desde el exterior Nivel n+1: Vista desde el interior

Figura 5. Diseño Descendente

1.4.3. Estructuras de Control

1.4.4. Teorema de la Programación Estructurada: Estructuras

En mayo de 1996, Bohm y Jacopini demostraron que un programa

La programación estructurada significa que:

 El programa completo tiene un diseño modular.

El objetivo fundamental de este manual es enseñar a resolver problemas

Problema Diseño del Programa de

Figura 6. Resolución de un Programa

Para llegar a la realización de un programa es necesario el diseño

1.5.1. Características de los Algoritmos

Las características fundamentales que debe cumplir todo

Dada una cantidad de datos de entrada de un algoritmo, se dice

1.5.2. Diseño del Algoritmo

Una computadora no tiene capacidad para solucionar problemas

Entrada de Cálculo de Cálculo de Salida de

Salida Salida Salida

Figura 7. Refinamiento de un Algoritmo

Tras los pasos anteriores (diseño descendente y refinamiento por

Diseño Refinamiento Herramientas de

Figura 8. Fases del Diseño de un Algoritmo