Fundamentos de programacion

1
FUNDAMENTOS DE PROGRAMACION
Clave SCD-1009
9:00 A.M- 10:00 A.M
Grupo: ISR
Alumno: Joaquín Martínez Benjamín
No. De control: 11161009
Profesora: Leal Cedillo Ana María
Carrera: Ingeniería en sistemas computacionales
UNIDAD 1
Semestre 3
Equipo1: “Los especiales”
Periodo escolar: Ago-Dic/2012

2
INDICE
N° DE PAG
TAREA 1.- TEMARIO, COMPETENCIAS Y BIBLIOGRAFÍA. ………………………….……..3
TAREA2.- RESUMEN. …………………………......................…………………………………...7
TAREA3.- ALGORITMO PARA CONTAR NÚMEROS PARES…………………………..…...12
TAREA4.- ALGORITMO PARA ENCONTRAR EL PROMEDIO GENERAL DE N
ALUMNOS…………….............................................................................................................…...15
TAREA 5.- INVESTIGACIÓN DE CONCEPTOS, TIPOS DE DATOS,
ATRIBUTOS, MÉTODOS, CLASE, HERENCIA,
ENCAPSULAMIENTO, MENSAJE, Y OBJETOS………………................................................18
TAREA 6.- ALGORITMO PARA OBTENER EL PROMEDIO GENERAL
DE N ALUMNOS CONSIDERANDO 1 A 4 MATERIAS…………………………………...…..21
TAREA 7.- INVESTIGACIÓN DE TIPOS DE
OPERADORES…………………………………………………………………………...….……..27
TAREA 8.- ALGORITMO DEL FACTORIAL DE UN NÚMERO..........................................…..30
TAREA 9.- ALGORITMO CUALITATIVO PARA IR DEL LUGAR DONDE ESTOY HACIA
LA PUERTA …………………………………………………………………………………...…..33

3
TEMARIO
1 Conceptos Básicos
1.1 Clasificación del software de: sistemas y aplicación.
1.2 Algoritmo.
1.3 Lenguaje de Programación.
1.4 Programa.
1.5 Programación.
1.6 Paradigmas de programación.
1.7 Editores de texto.
1.8 Compiladores e intérpretes.
1.9 Ejecutables.
1.10 Consola de línea de comandos.
2 Algoritmos
2.1 Análisis de problemas.
2.2 Representación de algoritmos: gráfica y pseudocódigo.
2.3 Diseño de algoritmos aplicados a problemas.
2.4 Diseño algorítmico de funciones
3Introducción a la Programación
3.1 Características del lenguaje de programación
3.2 Estructura básica de un programa.
3.3 Traducción de un programa:
compilación, enlace de un programa, errores en tiempo de compilación.
3.4 Ejecución de un programa.
3.5 Elementos del lenguaje: datos, literales y constantes, identificadores, variables, parámetros, operadores,
entrada y salida de datos.

4
3.6 Errores en tiempo de ejecución.
4 Control de flujo.
4.1 Estructuras secuenciales.
4.2 Estructuras selectivas: simple, doble y múltiple.
4.3 Estructuras iterativas: repetir mientras, hasta, desde
4.4 Diseño e implementación de funciones
5 Arreglos
5.1 Unidimensionales: conceptos básicos, operaciones y aplicaciones.
5.2 Multidimensionales: conceptos básicos, operaciones y aplicaciones.
COMPETENCIAS A DESARROLLAR
Competencias específicas:
Analizar, diseñar y desarrollar soluciones de problemas reales utilizando algoritmos computacionales para
implementarlos en un lenguaje de programación.
Competencias genéricas:
Competencias instrumentales
• Capacidad de análisis y síntesis.
• Capacidad de pensamiento lógico, algorítmico, heurístico, analítico y sintético.
• Resolución de problemas.
• Toma de decisiones.
• Destrezas tecnológicas relacionadas con el uso de maquinaria, destrezas de computación.
• Búsqueda y manejo de información.
Competencias interpersonales
•Capacidad crítica y autocrítica
• Trabajo en equipo
• Habilidades interpersonales
Competencias sistémicas
• Capacidad de aplicar los conocimientos en la práctica

5
• Habilidades de investigación
• Capacidad de aprender
• Capacidad de generar nuevas ideas (creatividad).
• Habilidad para trabajar en forma autónoma.
Búsqueda del logro
Unidad 1: Conceptos básicos
Unidad 2: Algoritmos
Unidad 3: Introducción a la programación
las características principales de un lenguaje de programación.
Unidad 4: Control de flujo
aumentar su funcionalidad.
Unidad 5: Arreglos
problemas.
OBJETIVO GENERAL DEL CURSO
Analizar, diseñar y desarrollar soluciones de problemas reales utilizando algoritmos computacionales para
implementarlos en un lenguaje de programación.

6
BIBLIOGRAFÍA
1. Luis Joyanes Aguilar, Fundamentos de Programación, Ed. Prentice Hall.
2. Jesús J. García Molina Introducción a la programación un Enfoque Algorítmico, Ed.Paraninfo.
3. Leobardo López Román, Metodología de la Programación Orientada a Objetos, Ed.Alfaomega.
4. Cairo Osvaldo, Metodología de la Programación, Ed. Alfaomega.
5. Deitel y Deitel. Como Programar en C++ quinta Edición. Prentice Hall.
6. Deitel y Deitel. Como Programar en C# quinta Edición. Prentice Hall.
7. Deitel y Deitel. Java como programar. Séptima edición. Prentice Hall.
8. Joyanes Aguilar, Luis Fernández, Azuela Matilde, Rodríguez Baena Luis, Fundamentos de Programación
Libro de Problemas Algoritmos Estructura de Datos y Objetos. 2a. edición Ed. Mc. Graw Hill 9. Luis Joyanes
Aguilar. Programación en JAVA 2 1ª Edición. Mc Graw Hill.
10. Martín Flowler Kendall Scott. UML Gota a Gota. Addison Wesley.
11. Ramírez Felipe, Introducción a la Programación, Algoritmos y su Implementación En Vb.Net C# Java y
C++, 2a. edición, Alfa Omega.
12. Jean-Paul Tremblay, Richar B. Bunt. Introducción a la Ciencia de Las Computadoras.
Enfoque Algorítmico. McGraw Hill.
13. Bjarne Storstrup. Lenguaje de Programación C/C++.
14. Cairo Battistutti Osvaldo, Metodología de la Programación, Algoritmos Diagramas de Flujo y Programas,
3a. edición, Alfa Omega.
15. Flores Cueto, Juan José, Método de las 6’D UML – Pseudocódigo – Java Enfoque Algorítmico, Serie
Textos Universitarios Facultad de Ingeniería y Arquitectura, ed.
Universidad de San Martín de Porres, (http://books.google.com/).

7
Software
Se requiere al equipamiento lógico o soporte lógico de un computador digital, comprende el
conjunto de los componentes lógicos necesarios para hacer posible la realización de una tarea
específica
Clasificación del software
Software de sistema: Su objetivo es desvincular adecuadamente al programador de los detalles
del computador en particular que se use, aislándolo especialmente del procesamiento referido a
las características internas de: memorias, puertos, dispositivos de comunicaciones, drivers,
etcétera. Este software procura al usuario y programador adecuadas interfaces de alto nivel y
utilidades de apoyo que permita su mantenimiento. Incluye:
-Sistemas operativos
-controladores de dispositivo
-Herramientas de diagnostico
-Herramientas de corrección y optimización
-Servidores
-Utilidades
Software de programación: Es el conjunto de herramientas que permiten al programador
desarrollar programas informáticos, usando diferentes alternativas y lenguajes de programación.
Incluye:
-Editores de texto -Compiladores
-Interpretes -Enlazadores
-Depuradores -Entornos de desarrollo integrados IDE
Software de aplicación: Aquel que permite a los usuarios llevar a cabo una o varias tareas
específicas en cualquier campo de actividad susceptible de ser automatizado o asistido. Incluye:
-Aplicaciones de control y automatización industrial
-Aplicaciones ofimáticas

8
-Software educativo
-Software médico
-Software de cálculo numérico
-Software de diseño asistido
-Software de control numérico
Sistema operativo
Es un software de sistema. Comienza a trabajar cuando se enciende el computador y gestiona el
hardware de la máquina, permitiendo también la interacción con el usuario.
Se puede encontrar normalmente en la mayoría de los aparatos electrónicos que utilicen
microprocesadores para funcionar. Nos brinda 5 funciones básicas:
Interfaces del usuario:
Es la parte del sistema operativo que permite comunicarse con el de tal manera que se puedan
cargar programas, acceder a archivos y realizar otras tareas.
Administración de archivos:
Un sistema de información contiene programas de administración de archivos que controlan la
creación, borrado y acceso de archivos de datos y programas.
Administración de tareas:
Los programas de administración, administran la realización de las tareas informáticas de los
usuarios finales. Pueden distribuir una parte específica del tiempo del CPU para una tarea en
particular e interrumpirlo en cualquier momento para sustituirla con una tarea de mayor
prioridad.
Servicio de soporte:
Estos servicios de soporte suelen consistir en;
-Actualización de versiones
-Mejoras de seguridad
-Inclusión de alguna nueva utilidad
-controladores para manejar nuevos periféricos

9
-Corrección de errores de software.
-Otros
Clasificación de los sistemas operativos
-Sistemas operativos de multiprogramación
En este una computadora procesa varias tareas al mismo tiempo. Para activar tareas que se
encuentren en segundo plano, el usuario debe traer al primer plano la ventana o pantalla que
contenga esa aplicación.
-Sistema operativo monotareas
Solo pueden manejar un proceso en cada momento o solo se pueden ejecutar tareas de una en
una.
-Sistema operativo monousuario
Solo pueden atender a un solo usuario. Son muy simples ya que todos los dispositivos de entrada,
salida y control dependen de la tarea que se está utilizando.
-Sistema operativo multiusuario
En esta categoría se encuentran todos los sistemas que cumplen simultáneamente las
necesidades de dos o más usuarios, que comparten mismos recursos.
-Sistemas operativos por lotes
Procesan una gran cantidad de trabajo con poca o ninguna interacción entre los usuarios y los
programas de ejecución.
Se reúnen todos los trabajos comunes para realizarlos al mismo tiempo evitando la espera de dos
o más trabajos.
-Sistemas operativos de tiempo real
Son aquellos en los cueles no tiene importancia el usuario sino los procesos, se utilizan en
entornos donde son procesados un gran número de sucesos o eventos. Se usan en aplicaciones
como control de tráfico aéreo, bolsas de valores, control de refinerías, control de laminadores.
-Sistemas operativos de tiempo compartido

10
Permiten la simulación de que el sistema y sus recursos son todos para cada usuario. El usuario
hace una petición a la computadora, está la procesa tan pronto como lo es posible y la respuesta
aparecerá en la terminal de usuario.
-Sistemas operativos distribuidos
Permiten distribuir trabajos, tareas o procesos, entre un conjunto de procesadores. Puede que los
procesadores estén en un equipo o en diferentes.
-Sistemas operativos de red
Son aquellos sistemas que mantienen a dos o más computadoras unidas a través de algún medio
de comunicación con el objetivo de poder compartir los diferentes recursos y la información del
sistema.
1.2 Definición de algoritmo
De forma sencilla podemos decir que un algoritmo es un conjunto de pasos que nos permite
obtener una solución. Debe cumplir estas condiciones:
Finitud: El algoritmo debe acabar tras un número finito de pasos.
Definibilidad: El algoritmo debe definirse de forma precisa para cada paso, es decir hay que evitar
toda ambigüedad, puesto que el lenguaje es impreciso, los algoritmos se expresan mediante un
lenguaje formal.
Entrada: El algoritmo debe tener entradas, es decir cantidades dadas antes de empezar el
algoritmo. Se trata siempre de cantidades representativas del mundo real expresadas de tal forma
que sean actas para su interpretación por el computador.
Salida: El algoritmo tiene una o más salidas en relación con las entradas.
Efectividad: Una persona debe ser capaza de realizar el algoritmo de modo exacto y sin ayuda de
una máquina en un lapso de tiempo finito.
Los pasos que hay que seguir son los siguientes:
1. Análisis previo del problema
2. Primera visión del método de resolución
3. Descomposición en módulos
4. Búsqueda de soluciones parciales
5. Ensamblaje de soluciones finitas

11
Lenguaje algorítmico
Es aquel por medio del cual se realiza un análisis previo del problema a resolver y encontrar un
método que permita resolverlo. El conjunto de todas las operaciones a realizar, y el orden en el
que deben efectuarse se le denomina algoritmo
El pseudocódigo
Es un conjunto de palabras reservadas y reglas para escribir algoritmos de una manera más
formal y estructurada. El objetivo es tener un algoritmo que este planteado en términos más
cercanos a los lenguajes de programación utilizados en la computadora.
El pseudocódigo no es un lenguaje de programación.

12
ALGORITMO PARA CONTAR LOS NÚMEROS PARES DE 1 A N.
Análisis
a)Leer el problema
Objetivo general: Contar cuantos pares hay en el intervalo de 1 a n
Objetivos secundarios:
b)Acotar el problema
2 ---------------- n
d)Interpretación Variables
conta=2
Preguntar 2<=10?
Si **
No*** ciclo
** contaP=contaP+1
contaP= conta + 2
***Imprimir contaP
n
conta
contaP
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
c)Representación matemática
n leer
conta <=n? conta contaP
2<=10? si
4<=10? si
6<=10? si
8<=10? si
10<=10? si
12<=10? No
2+2=4
4+2=6
6+2=8
8+2=10
10+2=12
0+1=1
1+1=2
2+1=3
3+1=4
4+1=5

13
e) Algoritmo
CPU
n=10
conta= 2,4,6,8,10,12
contaP=1,2,3,4,5
1.-Leer n
2.- conta=2
3.-contaP=0
4.-if conta <=n
Si------------------------- ir al paso 8
No----------------------- ir al paso 5
5.- contaP= contaP+1
6.-conta= conta + 2
7.-Ir al paso 4
8.-Fin
Pseudocódigo

15
Algoritmo para encontrar el promedio general de un grupo de n alumnos
Análisis
a) Leer y comprender el problema
Objetivo general: Obtener el promedio general
Número de alumnos
Promedio individual
1 n
d)Interpretación Variables
Leer n
*contaAlum= contaAlum +1
Leer calif
sumaCalif=sumaCalif + calif ciclo
if contaAlum < =n
Si------------------------------- ir a *
No ------------------------------ir a **
** promGen= sumaCalif /n
Imprimir “el promedio general es” ; promGen
Fin
n
contaAlum
calif
sumaCalif
promGen
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
leer n  n=4
Alumno = 1 <=n? 2 <=n? 3 <=n? 4<=n?
calif = 10 + 9 + 8 + 7
sumaCalif= 10+9=19
promGen= sumaCalif/ n
sumaCalif= 19+8=27
sumaCalif= 27+7=34
promGen= 34/4= 8.5

16
e) Algoritmo CPU
n=4
contaAlum=0,1,2,3,4,
calif=10,9,8,7
sumaCalif=10,19,27,34
promGen=8.5
Int contaAlum, calif,sumaCalif,promGen
cuentaAlum=1
sumaCalif=0
1.- Leer n
2.- contaAlum= cuentaAlum +1
3.- Leer calif
4.-sumaCalif=sumaCalif + calif
5.-if contaAlum <= n
Si------------------------------- ir al paso
2
No ------------------------------ir al paso
6
6.- promGen= sumaCalif /n
7.-Imprimir “el promedio general es” ;
promGen
8.-Fin
Pseudocódigo

18
Conceptos
Clase: Una clase es una colección de miembros dato y método que define un objeto especifico. Es
la construcción fundamental del lenguaje java y se declara class.
Atributo: También llamados datos o variable miembro son porciones de información que un
objeto posee o conoce de sí mismo.
Objeto: Es una entidad compuesta de varios datos y las operaciones que realizamos sobre esos
datos.
Método: Una serie de sentencias para llevar a cabo una acción, un juego de parámetros de
entrada que regularon dicha acción y posiblemente un valor de salida (o valor de retorno).
Encapsulamiento: Consiste en la combinación de los datos y las operaciones que se pueden
ejecutar sobre esos datos en un objeto, impidiendo usos indebidos al forzar que el acceso a los
datos se efectué siempre a través de los métodos objetos.
Herencia: Es la capacidad para crear nuevas clases (descendientes) que se construyen sobre otros
existentes, permitiendo que estas les transmitan sus propiedades.
Polimorfismo: Consigue que un mismo mensaje pueda actuar sobre diferentes tipos de objetos y
comportarse de modo distinto, por ejemplo cuando se obtienen nuevas clases a partir de una ya
existente, mediante esta derivación de clases o herencia.
Mensaje: Son la comunicación entre los objetos, sin los mensajes, los objetos tendrían que actuar
solos y no podríamos hacer productivo el uso de la programación.

19
Tipos de datos
Los tipos de datos primitivos contienen un solo valor e incluyen:
Enteros: Estos tipos son byte, short, int y long, que guardan el signo valor, estos representan un
número y no pueden representar elementos fraccionarios.
byte mi dato1=1;
short midato2=100;
int midato3=10000;
long midato4= 1000000000;
Número en coma flotante: Estos son float y double y pueden almacenar números en coma
flotante y con signo, esto quiere decir que nos permiten representar números decimales.
Todas las literales de coma flotante son del tipo doublé salvo que se especifique lo contrario, por
eso si se intenta asignar un literal en coma flotante a una variable de tipo float el compilador nos
dará un error.
El tipo carácter: Estos son de tipo char, que almacena la representación de los caracteres (letras o
números), un carácter esta almacenado en 16 bits, y sigue un estándar que es el Unicode.
El tipo booleano: Este solo guarda dos valores verdadero (true) o falso (false), y no ocurre en
otros lenguajes que toman los valores 0 y 1. Generalmente su utilización es muy frecuente para
determinados flujos de programas.
Tipos de datos Rango de valores Descripción
Números enteros
byte 8-bit complemento a 2 Entero de un byte
Short 16-bit complemento a 2 Entero corto
int 32-bit complemento a 2 Entero
long 64-bit complemento a 2 Entero largo
Números reales
float 32-bit IEEE 754 Coma flotante de precisión
simple
double 64-bit IEEE 754 Como flotante de precisión
doble
Otros tipos
char 16-bit carácter Un solo carácter
boolean True o false Un valor booleano (verdadero
o falso)

20
String
Contiene secuencias de puntos de código de 16 bits sin signo ( 2 bytes) que van de un valor de 0 a
65535.
Los tipos de datos cadena (String) son secuencias de caracteres que pueden llegar a tener la
longitud máxima de 255 . Cada carácter de esta cadena ocupa un byte de memoria .
En java las cadenas de caracteres son objetos que se manipulan aunque existan ciertas
operaciones como la creación de String. Un String se crea mediante el operador new.
String s = new String
Los String no se modifican una vez que se les asigna un valor si se le asigna se crea un nuevo
objeto String con el nuevo contenido.
´

21
Algoritmo para encontrar el promedio general de un grupo de n
alumnos, cada alumno tiene de 1 a 4 materias.
Análisis
1.- Leer y comprender el problema
Objetivo general: Obtener el promedio general de un grupo de n alumnos.
-Grupo: Número de alumnos
-Alumno: Número de materias por alumno
Calificación por materia
Promedio individual
2.-Acotar el problema
Alumno Materias
1
1 <=
4
n

22
3.- Representación matemática
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

contaMat = 1<=totMat? 2 <=totMat? 3 <=totMat? 4<=totMat?
calif = 8 + 9 + 10 + 9
sumaCalif= 8+9=17
promInd= sumaCalif/ totMat
sumaCalif= 17+10=27
sumaCalif= 27+9=36
promInd= 36/4= 9
contaMat = 1<=totMat? 2 <=totMat? 3 <=totMat? 4<=totMat?
calif = 8 + 9 + 10 + 8
sumaCalif= 8+9=17
promInd= sumaCalif/ totMat
sumaCalif= 17+10=27
sumaCalif= 27+8=35 acumProm= acumProm+promInd
promInd= 35/4= 8.75
promGen= 9 + 8.75 /2= 8.87

23
4.-Interpretación Variables
sumaCalif=0
contMat=1
acumProm=0
contaAlum=1
Leer n
***Leer “ total de materias”; totMat
If (totMat >= 1) && (totMat<=4)
Si------------------- ir al paso *
No----------------- “error”
*Leer calif
sumaCalif= sumaCalif + calif
contaMat= contaMat +1
if (contaMat<= totMat)
Si---------------------- ir al paso* ciclo
No--------------------- ir al paso **
**promInd=sumaCalif/totMat
acumProm= acumProm + promInd
contaAlum= contaAlum + 1
if conta alum <= n
Si------------------------------ ir al paso ***
No----------------------------- ir al paso ****
**** promGen= acumProm /n
Imprimir “el promedio general es ”; promGen
Fin
n
totMat
contaAlum
calif
sumaCalif
contMat
promInd
acumProm
promGen
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

24
5.-Algoritmo
CPU
n=2
totMat=4,4
contaAlum =1,2
calif=8,9,10,9, 8,9,10,8
sumaCalif=8,17,27,36, 8,17,27,35
contMat=1,2,3,4, 1,2,3,4,
promInd= 9, 8.75
acumProm=9,17.75
promGen=8.87
sumaCalif=0
contMat=1
acumProm=0
contaAlum=1
1.- Leer n
2.- Leer “ total de materias”; totMat
3.- If (totMat >= 1) && (totMat<=4)
Si-------------------
ir al paso 4
No-----------------
“error”
4.- Leer calif
5.-sumaCalif= sumaCalif + calif
6.- contaMat= contaMat +1
7.- if (contaMat<= totMat)
Si---------------------- ir al
paso 4
No--------------------- ir al
paso 8
8.- promInd=sumaCalif/totMat
9.-acumProm= acumProm + promInd
10.- contaAlum= contaAlum + 1
11.- if conta alum <= n
Si------------------------------ ir al
paso 2
No----------------------------- ir al
paso 12
12.- promGen= acumProm /n
13.- Imprimir “el promedio general es ”;
promGen
14.-Fin

27
Tipos de operadores
Operadores Aritméticos
Existen 5 operadores aritméticos cuyo significado se muestra en esta tabla:
Operador Nombre Ejemplo
+ Suma 3 + 5
- diferencia 3-4
* producto 3*4
/ corriente 20/7
% modulo 20%7
EL cociente entre dos enteros da como resultado un entero. Por ejemplo, al dividir 20 entre 7 nos
da como resultado 2.
El operador módulo da como resultado el resto de la división entera, por ejemplo 20 % 7 da como
resultado 6 que es el resto de la división entre 20 y 7.
Los operadores lógicos
Los operadores lógicos son:
-&& AND (el resultado es verdadero si ambas expresiones son verdaderas)
-|| OR (el resultado es verdadero si alguna expresión es verdadera)
- ! NOT (el resultado invierte la condición de la expulsión)
AND y OR trabajan con dos operadores y retoman un valor lógico basados en los denominados
tablas de verdad. El operador NOT actúa sobre un operando. Estas tablas de verdad son conocidas
y usadas en el contexto de la vida diaria. Las tablas de verdad de los operadores AND, OR y NOT se
muestran en la tabla siguiente:

28
El operador lógico AND
X y Resultado
True True True
True False False
False True False
false false False
El operador lógico OR
X y Resultado
True True True
True False True
False True True
false false False
El operador lógico NOT
X Resultado
True false
false true
Los operadores AND y OR combinan expresiones relacionales cuyo resultado viene dado por la
última columna de sus tablas de verdad. Ejemplo:
(a<b) && (b<c) es verdadero si ambos son verdaderos
(a<b)|| (b<c) es verdadero si uno de las condiciones lo es
La expresión “ No es menor que b” se representan asi : !(a<b)

29
Los operadores relacionales
Los operadores relacionales son símbolos que se usan para comparar dos valores. Si el resultado
de la comparación es correcto la expresión considerada es verdadera, en caso contrario es falsa.
Operador Nombre Ejemplo Significado
< Menor que a<b a es menor que b
> Mayor que a>b a es mayor que b
== Igual a a==b a es igual que b
!= No igual a a!=b a es distinto que b
<= Menor que o igual a a<=b a es menor o igual
que b
>= Mayor que o igual a a>=b a es mayor o igual que
b

30
Algoritmo para encontrar el factorial de un número n
Análisis
a) Leer y entender el problema
Objetivo general: Encontrar el factorial de un número entero cualquiera introducido por el
usuario del algoritmo
n----------------------------------------------------------1
d) Interpretación Variables
auxiliar= n-1= 3
factorial= n * auxiliar=12
if auxiliar= 1
si ***
no**
**auxiliar= auxiliar -1
factorial = factorial * auxiliar
if auxiliar= 1
si ***
no**
imprimir factorial
n
auxiliar
factorial
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
n=4 Le damos un valor a n
fact= 4 * 3 * 2 * 1
fact= 12
fact= 24
fact= 24
ciclo

31
e) Algoritmo
CPU
n=4
auxiliar=3,2,1
factorial=12,24,24
1.- Inicio
2.- Leer n
3.- auxiliar= n-1
4.- factorial= n * auxiliar
5.- if (auxiliar=1)
Si ir al paso 9
No ir al paso 6
6.- auxiliar= auxiliar – 1
7.- factorial= factorial * auxiliar
8.- Volver al paso 5
9.- Imprimir “El factorial es”; factorial.
10.- Fin
Pseudocódigo

33
Algoritmo cualitativo para ir desde el lugar donde estoy a la puerta
del aula
1.- Inicio
2.- Levantarme
3.- Girar 90 ° a la derecha
4.- Caminar 2 pasos
5.- Girar 90 ° a la izquierda
6.- Avanzar 10 pasos
7.- Girar 90 ° grados a la derecha
8.- Avanzar 2 pasos
9.- Preguntar ¿llegue a la puerta?
Si ir al paso 10
No ir al paso 8
10.- Fin

34
Clave SCD-1009
9:00 A.M- 10:00 A.M
Grupo: ISR
UNIDAD 2
Semestre 3

35
INDICE
N° DE PAG
Programa para mostrar números de 1 a n. ………………………….………………………....4
-Usando do while……………………………………………………………………………………4
-Usando while………………………………………………………………………………………5
-Usando for…………………………………………………………………………………………6
-Ejemplo…………………………………………………………………………………………….7
Programa para contar pares. …………………………......................…………………………...8
-Usando do while……………………………………………………………………………………8
-Usando while……………………………………………………………………………………….9
-Usando for…………………………………………………………………………………………10
-Ejemplo…………………………………………………………………………………………….11
Programa para leer un lista de n números y determinar si son pares o impares………….12
-Usando do while…………………………………………………………………………………12
-Usando while……………………………………………………………………………………13
-Usando for…………………………………………………………………………………………14.
-Ejemplo…………………………………………………………………………………………….15
Programa para encontrar el promedio general de 1 a n alumnos………………………..…...16
-Usando do while…………………………………………………………………………………..16
-Usando while……………………………………………………………………………………..17
-Usando for………………………………………………………………………………………..18
-Ejemplo…………………………………………………………………………………………….19

36
Programa para encontrar el promedio general de 1 a n alumnos considerando 1 a 4
materias…………….............................................................................................................…...20
-Usando do while…………………………………………………………………………………20
-Usando while…………………………………………………………………………………….22
-Usando for…………………………………………………………………………………………24
-Ejemplo…………………………………………………………………………………………….26
Programa para obtener el factorial de un número........................................…………………..28
-Usando do while……………………………………………………………………………………28
-Usando while………………………………………………………………………………………29
-Usando for…………………………………………………………………………………………30
-Ejemplo…………………………………………………………………………………………31
Programa para obtener la sucesión de Fibonacci hasta un número n.................................…..32
-Usando do while……………………………………………………………………………………32
-Usando while………………………………………………………………………………………33
-Usando for…………………………………………………………………………………………34
-Ejemplo…………………………………………………………………………………………35
Programa para imprimir un triángulo.................................................................................…..36
-Ejemplo…………………………………………………………………………………………37
Programa para encontrar el mayor y el menor de n números y mostrar su posición en el
arreglo.....................................................................................................................................…..38
-Ejemplo…………………………………………………………………………………………39
Programa para ordenar alfabéticamente un arreglo de nombres.................................…..40
-Ejemplo…………………………………………………………………………………………42
Programa que imprime el recibo referente al peaje de la autopista México-
Puebla..................................................................................................................................…..43
-Ejemplo…………………………………………………………………………………………45

37
/**@ ITO Fundamentos de programación
* @(#)Cuenta.java
* @ Este programa imprime números de 1 a n (usando do while)
* @author Joaquín Martínez Benjamín
* @versión 1.00 2012/10/13
*/
import javax.swing. *;
public class Cuenta{
public Cuenta(){}
public void imprimirCuenta(){
int n;
int contaN=1;
String imprimir= " ";
n =Integer.parseInt(JOptionPane.showInputDialog("Introduzca el total de
numeros a imprimir"));
do{
imprimir += String.valueOf(contaN)+" ";
contaN++;
}
while (contaN<=n);
JOptionPane.showMessageDialog(null,"El resultado es: n " + imprimir);
}
public static void main (String[]args)
{
Cuenta result= new Cuenta ();
result.imprimirCuenta();}
}

38
* @(#)Cuenta2.java
* @ Este programa imprime números de 1 a n (usando while)
* @versión 1.00 2012/10/13
*/
public class Cuenta2{
public Cuenta2(){}
int n;
int contaN=1;
while (contaN<=n)
{
contaN++;
}
}
{
Cuenta2 result= new Cuenta2 ();
}

39
* @(#)Cuenta3.java
* @ Este programa imprime números de 1 a n (usando for)
* @versión 1.00 2012/10/13
*/
public class Cuenta3{
public Cuenta3(){}
int n;
int contaN=1;
for(contaN=1;contaN<=n;contaN++) {
}
}
{
Cuenta3 result= new Cuenta3();
}

41
* @(#)Pares.java
* @ Este programa cuenta los numeros pares de 2 a n (usando do while)
* @version 1.00 2012/10/13
*/
public class Pares {
public Pares(){}
public void cuentaPares() {
int conta=2;
int contaP=0;
int n= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número para calcular los pares"));
do{
contaP= contaP +1;
conta= conta +2;
}
while (conta <=n);
JOptionPane.showMessageDialog(null, "El número de pares es: "+ contaP);
}
{
Pares result= new Pares();
result.cuentaPares(); }
}

42
* @(#)Pares.java
* @ Este programa cuenta los numeros pares de 2 a n (usando while)
* @version 1.00 2012/10/13
*/
public class Pares2 {
public Pares2(){}
int conta=2;
int contaP=0;
while(conta <=n) {
contaP=contaP+1;
conta=conta +2;
}
}
{
Pares2 result= new Pares2();
result.cuentaPares();}
}

43
* @(#)Pares.java
* @ Este programa cuenta los numeros pares de 2 a n (usando for)
* @version 1.00 2012/10/13
*/
public class Pares3 {
public Pares3(){}
int conta;
int contaP=0;
for(conta=2;conta<=n;conta=conta+2) {
contaP=contaP+1;
}
}
{
Pares3 result= new Pares3();
result.cuentaPares();}
}

45
* @(#)ParImpar.java
* @ Este programa lee una lista de n numeros y evalua si son pares o impares (usando do while)
* @version 1.00 2012/10/13
*/
public class ParImpar{
public ParImpar(){}
public void evaluarN(){
int n,num;
int contaN=1;
numeros a evaluar"));
do{
num= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el numero" +contaN+ " a
evaluar"));
if (num % 2==0){
imprimir += String.valueOf(num)+" es parn";
}
else {
imprimir += String.valueOf(num)+" es impar n";
}
contaN++;
}
while (contaN<=n);
}
{
ParImpar result= new ParImpar ();
result.evaluarN();}
}

46
* @(#)ParImpar2.java
* @ Este programa lee una lista de n numeros y evalua si son pares o impares( usando while)
* @version 1.00 2012/10/13
*/
public class ParImpar2{
public ParImpar2(){}
int n,num;
int contaN=1;
while (contaN<=n){
evaluar"));
if (num % 2==0){
}
else {
imprimir += String.valueOf(num)+" es impar n";
}
contaN++;
}
}
{
ParImpar2 result= new ParImpar2 ();
result.evaluarN();}
}

47
* @(#)ParImpar3.java
* @ Este programa lee una lista de n numeros y evalua si son pares o impares(usando for)
* @version 1.00 2012/10/13
*/
public class ParImpar3{
public ParImpar3(){}
int n,num;
int contaN;
String imprimir= "";
for (contaN=1;contaN<=n;contaN++){
evaluar"));
if (num % 2==0){
}
else {
imprimir += String.valueOf(num)+" es imparn";
}
}
JOptionPane.showMessageDialog(null,"El resultado es:n " + imprimir);
}
{
ParImpar3 result= new ParImpar3();
result.evaluarN();}
}

49
* @(#)PromedioGeneral.java
* @ Este programa obtiene el promedio general de n alumnos(usando do while)
* @version 1.00 2012/10/13
*/
public class PromedioGeneral {
public PromedioGeneral(){}
public void obtenerPromedio() {
//////Declaracion de variables//////
int n,contaAlum, calif,sumaCalif,promGen;
//////Inicialización de variables///
contaAlum=0;
sumaCalif=0;
promGen=0;
///// Leer n///////
n= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número de alumnos"));
/////////////////////////////////////Ciclo//////////////////
do {
contaAlum=contaAlum+1;
///////Leer calif////
calif= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el promedio individual del alumno "
+ contaAlum));
sumaCalif=sumaCalif+calif;
}while (contaAlum < n);
promGen= sumaCalif /n;
JOptionPane.showMessageDialog(null, "El promedio general es: "+ promGen);
}
{
PromedioGeneral result= new PromedioGeneral();
result.obtenerPromedio(); }
}

50
* @ Este programa obtiene el promedio general de n alumnos(usando while)
* @version 1.00 2012/10/13
*/
public class PromedioGeneral2 {
public PromedioGeneral2(){}
contaAlum=0;
sumaCalif=0;
promGen=0;
///// Leer n///////
/////////////////////////////////////Ciclo//////////////////
while (contaAlum < n){
calif= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el promedio individual del alumno
"
+ contaAlum));
}
////////////////////////////////////////////////////////////
}
{
PromedioGeneral2 result= new PromedioGeneral2();
}

51
* @ Este programa obtiene el promedio general de n alumnos(usando for)
* @version 1.00 2012/10/13
*/
public class PromedioGeneral3 {
public PromedioGeneral3(){}
sumaCalif=0;
promGen=0;
///// Leer n///////
/////////////////////////////////////Ciclo//////////////////
for(contaAlum=0;contaAlum<n;contaAlum++){
calif= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el promedio individual del alumno "
+ contaAlum));
}
////////////////////////////////////////////////////////////
}
{
PromedioGeneral3 result= new PromedioGeneral3();
}

53
* @ Este programa obtiene el promedio general de n alumnos
* considerando el límite de 1 a 4 materias (usando do while)
* @version 1.00 2012/10/13
*/
public class PromedioGeneralLimites {
public PromedioGeneralLimites(){}
int n, contMat, totMat,contaAlum;
float promInd, acumProm, calif,sumaCalif,promGen;
sumaCalif=0;
contMat=1;
acumProm=0;
contaAlum=1;
promGen=0;
///// Leer n///////
/////////////////////////////////////Ciclo//////////////////
do {
do{
totMat= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el total de materias del alumno"
+ contaAlum));
}while (!((totMat >= 1)&&(totMat<=4)));
do{
calif= Integer.parseInt(JOptionPane.showInputDialog("Introduzca la calificacion " + contMat+ "del "
+"alumno" + contaAlum));
sumaCalif= sumaCalif + calif;
contMat= contMat +1;
}while (contMat<=totMat);
contaAlum=contaAlum +1;
promInd=sumaCalif/totMat;
acumProm=acumProm+promInd;
contMat=1;
sumaCalif=0;
} while (contaAlum<=n) ;
////////////////////////////////////////////////////////////
promGen= acumProm/n;
}

54
{
PromedioGeneralLimites result= new PromedioGeneralLimites();
}

55
* considerando el limite de 1 a 4 materias (usando while)
* @version 1.00 2012/10/13
*/
public class PromedioGeneralLimites2 {
public PromedioGeneralLimites2(){}
int n, contaMat, totMat,contaAlum;
float promInd, acumProm,calif,sumaCalif, promGen;
sumaCalif=0;
contaMat=1;
acumProm=0;
contaAlum=1;
promGen=0;
totMat=0;
///// Leer n///////
/////////////////////////////////////Ciclo//////////////////
while (contaAlum<=n) {
while (!((totMat >= 1) && (totMat<=4))) {
+ contaAlum));
}

56
while (contaMat<=totMat) {
calif= Integer.parseInt(JOptionPane.showInputDialog("Introduzca la calificacion " + contaMat+ "del "
contaMat= contaMat +1;
}
contaMat=1;
sumaCalif=0;
totMat=0; }
///////////////////////////////////////////////////////////////////
}
{
PromedioGeneralLimites2 result= new PromedioGeneralLimites2();
}

57
* considerando el limite de 1 a 4 materias (usando for)
* @version 1.00 2012/10/13
*/
public class PromedioGeneralLimites3 {
public PromedioGeneralLimites3(){}
int n, contaMat, totMat,contaAlum;
float promInd, acumProm,calif,sumaCalif, promGen;
sumaCalif=0;
acumProm=0;
promGen=0;
///// Leer n///////
/////////////////////////////////////Ciclo/////////////////
for(contaAlum=1; contaAlum<=n;contaAlum=contaAlum +1){
for (totMat=0;!((totMat >= 1)&&(totMat<=4)) ;totMat=totMat + 0) {
+ contaAlum));
}
for(contaMat=1; contaMat<=totMat;contaMat=contaMat+1)
{ calif= Integer.parseInt(JOptionPane.showInputDialog("Introduzca la calificacion " + contaMat+
"del "
}
sumaCalif=0;}

58
///////////////////////////////////////
}
{
PromedioGeneralLimites3 result= new PromedioGeneralLimites3();
}

60
* @(#)Factorial.java
* Programa corregido
* Este programa obtiene el factorial de un número n (usando for)
* @version 2.00 2012/10/12
*/
public class Factorial {
public Factorial(){}
public void Mfactorial() {
int n,i;
int fact=1;
n= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número para
calcular el factorial"));
for (i=1;i <=n; i++){
fact= (fact*i);
}
JOptionPane.showMessageDialog(null, "El factorial de" + n+"es: "+ fact);
}
{
Factorial result= new Factorial ();
result.Mfactorial(); }
}

61
/**@ITO Fundamentos de programación
* @(#)Factorial2.java
* @ Este programa obtiene el factorial de un número(usando do while)
* @version 1.00 2012/10/13
*/
public class Factorial2 {
public Factorial2(){}
public void obtenerFactorial(){
//////////////////////////////////////////////////////////////
int n, factorial, auxiliar;
n= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número para calcular el
factorial"));
auxiliar= n-1;
factorial= n* auxiliar;
do
{
auxiliar=auxiliar -1;
factorial=factorial *auxiliar;}
while (auxiliar !=1);
JOptionPane.showMessageDialog(null, "El factorial de" + n+"es: "+ factorial);
////////////////////////////////////////////////////////
}
{
Factorial2 resultado= new Factorial2 ();
resultado.obtenerFactorial();}
}

62
* @ Este programa obtiene el factorial de un número(usando while)
* @version 1.00 2012/10/13
*/
//////////////////////////////////////////////////////////////
factorial"));
auxiliar=n-1;
factorial= n*auxiliar;
while (auxiliar !=1){
factorial=factorial *auxiliar;
}
////////////////////////////////////////////////////////
}
{
}

63
* @ Este programa obtiene el factorial de un número(usando while)
* @version 1.00 2012/10/13
*/
//////////////////////////////////////////////////////////////
factorial"));
auxiliar= n-1;
factorial= n* auxiliar;
for (auxiliar=auxiliar-1; auxiliar !=1;auxiliar=auxiliar-1) {
}
////////////////////////////////////////////////////////
}
{
}

65
* @(#)Fibonacci.java
* @ Este programa obtiene la sucesión de fibonacci( usando do while)
* @version 1.00 2012/10/13
*/
public class Fibonacci {
public Fibonacci(){}
public void imprimirFibonacci(){
int n, antecesor, sucesor,resultado;
antecesor=0;
sucesor=1;
resultado=sucesor;
n= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número para imprimir la
sucesión"));
do{
imprimir += String.valueOf(resultado)+" ";
resultado=antecesor + sucesor;
antecesor= sucesor;
sucesor= resultado;
}
while (!(sucesor > n));
JOptionPane.showMessageDialog(null,"La sucesión de fibonacci es:n " + imprimir);
}
{
Fibonacci result= new Fibonacci ();
result.imprimirFibonacci();}
}

66
* @(#)Fibonacci2.java
* @version 1.00 2012/10/13
*/
public class Fibonacci2 {
public Fibonacci2(){}
antecesor=0;
sucesor=1;
resultado=sucesor;
sucesión"));
while (!(sucesor > n))
{
resultado=antecesor + sucesor;
antecesor= sucesor;
sucesor= resultado;
}
}
{
Fibonacci2 result= new Fibonacci2 ();
result.imprimirFibonacci();}
}

67
* @(#)Fibonacci3.java
* @version 1.00 2012/10/13
*/
public class Fibonacci3 {
public Fibonacci3(){}
antecesor=0;
sucesor=1;
imprimir = String.valueOf(sucesor)+" ";
sucesión"));
for(resultado=sucesor; !(resultado > n); resultado= antecesor + sucesor) {
antecesor= sucesor;
sucesor= resultado; }
}
{
Fibonacci3 result= new Fibonacci3();
result.imprimirFibonacci();
}
}

69
import javax.swing.JOptionPane;
public class Triangulos{
public Triangulos(){}
public void hacerTriangulo(){
int num,i=1;
num=Integer.parseInt(JOptionPane.showInputDialog (" Introduzca un número de 1"));
for (i=1; i<=num; i++) //filas
{
for(int j=i -1; j<=num; j++){
System.out.print (" ");
}
for(int k=0; k<2*i-1; k++){
System.out.print (" *");
}
System.out.print (" n");
}
}
public static void main (String [] args){
Triangulos result = new Triangulos();
result.hacerTriangulo ();
}
}

71
public class Recibo{
public Recibo(){}
double precio;
String vehiculo;
{
Recibo peaje= new Recibo ();
peaje.generarRecibo();
}
public void generarRecibo(){
int tipo=Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número
del vehiculo:n"
+ "1:Motocicletan 2:Carro de 4 cilindrosn 3:Camioneta de 4 cilindrosn
4:Camioneta de 8 cilindrosn 5:Autobusn 6:Trailern"));
String Nomcaseta=JOptionPane.showInputDialog("Nombre de la caseta:n");
int numfolio=Integer.parseInt(JOptionPane.showInputDialog("Número de folion"));
int numboleta=Integer.parseInt(JOptionPane.showInputDialog("Número de la boletan"));
double kilometros=Integer.parseInt(JOptionPane.showInputDialog("kilometros
recorridos:n"));
int dia= Integer.parseInt(JOptionPane.showInputDialog("Día:n"));
int mes= Integer.parseInt(JOptionPane.showInputDialog("Mes:n"));
int anio=Integer.parseInt(JOptionPane.showInputDialog("Año:n"));
String fecha= " " + dia+ "/ "+ mes + " /" +anio ;
int hora= Integer.parseInt(JOptionPane.showInputDialog("Hora:n"));
int minuto=Integer.parseInt(JOptionPane.showInputDialog("Minuto:n"));
String horas= "" +hora+":"+minuto+" Hrs.";
switch (tipo){
case 1:
precio=kilometros * 0.5;
vehiculo="Motocicletan ";
break;
case 2:

72
vehiculo="Carro de 4 cilindrosn ";
break;
case 3: precio=kilometros * 1.50;
vehiculo="Camioneta de 4 cilindrosn";
break;
case 4:
vehiculo="Camioneta de 8 cilindrosn";
break;
case 5:
vehiculo="Autobusn";
break;
case 6:
vehiculo="Trailern";
break;
default:
JOptionPane.showMessageDialog (null,"Número invalido");
break;
}
String factura = "_______________________AUTOPISTA MEXICO-
PUEBLA________________________n"
+" nnVehiculo: "
+ vehiculo
+" nnKilometros recorridos: "
+ kilometros
+" nnPrecio por kilometros recorridos: $"
+ precio
+" nn Nombre de la caseta: "
+ Nomcaseta
+" nn Fecha:"
+ fecha
+" nn Hora: "
+ horas
+" n Número de folio: "
+ numfolio
+" n Número de boleta: "
+ numboleta
+"
nn__________________________________________________________________________";
JOptionPane.showMessageDialog (null,factura);
}
}

75
Clave SCD-1009
9:00 A.M- 10:00 A.M
Grupo: ISR
UNIDAD 3
Arreglos unidimensionales

76
INDICE
N° DE PAG
Programa que lee un arreglo unidimensional para después imprimirlo…………………………….3
Programa que lee un arreglo unidimensional para despues ordenarlo de menor a mayor…………..5
Programa que lee un arreglo unidimensional, busca el mayor y el menor del arreglo
y su lugar en el arreglo . ……………………………………………………………………….7
Programa que lee una lista de n nombres de empleados y los ordena alfabéticamente……………10

77
* @ Este programa lee un arreglo unidimensional para después imprimirlo
*/
import javax. swing. *;
public class Arreglos{
public Arreglos(){}
public void Numeros(){
int i;
int n;
String matrizImpresa="";
n= Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número de elementos del
arreglo"));
int matriz []=new int [n];
//////////////////////////////////////////////////////////////////////////////////////////////////
for (i=0; i < n; i++) {
matriz [i]= Integer.parseInt (JOptionPane.showInputDialog ("Escriba los elementos del arreglo"));
}
//////////////////////////////////////////////////////////////////////////////////////////////////
for (i=0; i < n; i++) {
matrizImpresa +="["+ matriz [i]+"]" +"n";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa);
//////////////////////////////////////////////////////////////////////////////////////////////////
}
Arreglos result= new Arreglos();
result.Numeros();
}
}

79
* @ Este programa lee un arreglo unidimensional para despues ordenarlo de menor a mayor
*/
public class OrdenarArreglo{
public OrdenarArreglo(){}
int i;
int aux;
int n= Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el número de elementos del
arreglo"));
int arreglo []=new int [n];
public void leerImprimir(){
//////////////////////////////////////////////Rellena el arreglo//////
for (i=0; i < n; i++) {
arreglo [i]= Integer.parseInt (JOptionPane.showInputDialog ("Escriba los elementos del
arreglo"));
}
/////////////////////////////////////////// Imprime el arreglo desordenado
for (i=0; i < n; i++) {
matrizImpresa +="["+ arreglo [i]+"]" +"n";
}
JOptionPane.showMessageDialog(null,"El arreglo desordenado es: n"+matrizImpresa);
}
public void ordenaArreglo(){
//////////////////////////////////////////////// Ordena el arreglo
for (int x=0; x < n-1; x++)
for (int y=x+1; y < n; y++){
if (arreglo [x]>arreglo [y])
{ aux=arreglo[x];
arreglo [x]=arreglo[y];
arreglo[y]=aux;
}
}
}

80
////////////////////////////////////Imprime el arreglo ordenado
public void imprimeOrdenado(){
matrizImpresa="";
for (i=0; i < n; i++) {
}
JOptionPane.showMessageDialog(null,"El arreglo ordenado es: n"+matrizImpresa);
///////////////////////////////////////////////////////////////////
}
OrdenarArreglo result= new OrdenarArreglo();
result.leerImprimir();
result.ordenaArreglo();
result.imprimeOrdenado();
}
}

81
* @ Este programa lee un arreglo unidimensional, busca el mayor y el menor del arreglo
y su lugar en el arreglo
public class Numero{
String imprimir="";
int subindice= 0;
int subindice2=0;
int maximo=0;
int minimo=0;
int n= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de elementos del
arreglo"));
int arreglo[]=new int [n];
public Numero(){}
Numero result= new Numero();
result.leerArreglo();
result.buscarMayMe();
result.imprimirResultado();
}
public void leerArreglo(){
/////////////////////////////////////////////////////////////////////////////////////////////////////
for (int i=0; i < n; i++) {
arreglo [i]= Integer.parseInt (JOptionPane.showInputDialog ("Ingrese el elemento " + i+ " del
arreglo"));
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
public void buscarMayMe(){
maximo=arreglo [0];
minimo=arreglo [0];
for (int i=0; i < n; i++) {
if( arreglo [i]>maximo ){maximo=arreglo [i];
subindice= i;}
if( arreglo [i]<minimo ){minimo=arreglo [i];
subindice2= i;}
}
}

82
/////////////////////////////////////////////////////////////////////////////////////////////////////
public void imprimirResultado(){
for (int i=0; i < n; i++) {
if(arreglo [i]==maximo){imprimir +=i+"="+ arreglo [i] +" Es el mayor y su lugar es el "+i+"n";}else{
if(arreglo [i]==minimo){imprimir +=i+"="+ arreglo [i] +" Es el menor y su lugar es el "+i+"n";}else{
imprimir +=i+"="+ arreglo [i] +"n";}}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
JOptionPane.showMessageDialog(null,"::::ARREGLO:::: n"+imprimir);
}
}

84
* @ Este programa lee una lista de n nombres de empleados y los ordena alfabeticamente
*/
public class Nombres{
int i;
int n=Integer.parseInt(JOptionPane.showInputDialog("Introduzca el número de elementos del
arreglo"));
String arreglo []=new String[n];
public Nombres(){}
public void leerNombres(){
for (i=0; i < n; i++) {
arreglo [i]= JOptionPane.showInputDialog ("Escriba los elementos del arreglo");
}
}
public void imprimirNombres(){
for (i=0; i < n; i++) {
}
JOptionPane.showMessageDialog(null,"El arreglo desordenado es: n"+matrizImpresa);
}
public void ordenarNombres() {
for(int j = 0; j < arreglo.length; j++) {
for( i = j + 1; i < arreglo.length; i++) {
if(arreglo[i].compareTo(arreglo[j]) < 0) {
String aux = arreglo[j];
arreglo[j] = arreglo[i];
arreglo[i] = aux;
}
}
}
}

85
public void imprimirOrdenados(){
matrizImpresa="";
for (i=0; i < n; i++) {
}
JOptionPane.showMessageDialog(null,"El arreglo ordenado es: n"+matrizImpresa);
}
Nombres result= new Nombres();
result.leerNombres();
result.imprimirNombres();
result.ordenarNombres();
result.imprimirOrdenados();
}
}

87
Clave SCD-1009
9:00 A.M- 10:00 A.M
Grupo: ISR
UNIDAD 4
Arreglos bidimensionales

88
INDICE
N° DE PAG.
Programa que lee un arreglo bidimensional para después imprimirlo……………………………3
Programa que lee un arreglo bidimensional para después imprimirlo separando el método leer del
método imprimir……………………………………………………………….…………………5
Programa que lee por columnas un arreglo bidimensional para después imprimirlo…………….7
Programa que lee un arreglo bidimensional e imprime los valores de la
diagonal principal……………………………………………………………………………….9
Programa que lee una matriz e imprime su diagonal principal ordenada…………………………11
Programa que lee una matriz y la convierte en un vector de acuerdo al orden
de filas y un vector de acuerdo al orden de columnas…………………………………………..14
Programa que lee una matriz e imprime su perímetro…………………………………………..17
Programa que lee una matriz y ordena las filas en de menor a mayor
y las columnas de mayor a menor……………………………………………………………….20
Programa que lee una matriz A, una Matriz B, multiplica la Matriz A por la matriz B y guarda
los resultados en una matriz C para después imprimir las tres Matrices………………………23
Programa que lee una matriz bidimensional e imprime su transpuesta………………………...27
Programa que lee una matriz bidimensional y cambia las diagonales
principales…………………………………………………………………………………………29
Programa que lee una matriz bidimensional e imprime la matriz
simetrica basandose en los valores de arriba de la diagonal……………………………………….32

89
* @ Este programa lee un arreglo bidimensional para después imprimirlo
*/
import javax.swing.*;
public class LeerXfila {
public LeerXfila(){}
int n[][];
int renglon,columna;
public void leerHacer(){
renglon=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de renglones"));
columna=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de columnas"));
n= new int [renglon] [columna];
for (int x=0; x<renglon; x++) {
for (int y=0; y <columna; y++) {
n[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el elemento
["+x+"]["+y+"] del arreglo"));
matrizImpresa+= n[x][y] + " ";
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"El arreglo es: n"+matrizImpresa);
}
public static void main ( String args []){
LeerXfila result= new LeerXfila ();
result.leerHacer();
}
}

91
* @ Este programa lee un arreglo bidimensional para después imprimirlo
* separando el método leer del método imprimir
*/
public class LeerXfila2 {
public LeerXfila2(){}
int renglon=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de renglones"));
int columna=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de columnas"));
int n[][]= new int [renglon] [columna];
public void leer(){
n[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el elemento ["+x+"]["+y+"]
del arreglo"));
}
}
}
public void hacer(){
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"El arreglo es: n"+matrizImpresa);
}
LeerXfila2 result= new LeerXfila2 ();
result.leer();
result.hacer();
}
}

93
* @ Este programa lee por columnas un arreglo bidimensional para después imprimirlo
*/
public class LeerXcolumna {
public LeerXcolumna(){}
int n[][];
int transpuesta[][];
columna=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de renglones"));
renglon=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de columnas"));
transpuesta= new int [columna][renglon];
n[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el elemento
["+y+"]["+x+"] del arreglo"));
}
}
for (int x=0; x<columna; x++) {
for (int y=0; y <renglon; y++) {
transpuesta[x][y]=n[y][x];
matrizImpresa+=transpuesta[x][y] + " ";
}
matrizImpresa+="n";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa);
}
LeerXcolumna result= new LeerXcolumna ();
result.leerHacer();
}
}

95
* @ Este programa lee un arreglo bidimensional e imprime los valores de la
* diagonal principal
*/
public class ImprimirDiagonal{
public ImprimirDiagonal(){}
int n = Integer.parseInt (JOptionPane.showInputDialog (" Inserte el número de columnas"));
int conta=0;
String diagonal= "";
int [][]matriz= new int [n][n];
public void crearMatriz() {
for(int x=0; x<n; x++)
for(int y=0; y<n; y++)
{
matriz[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Ingrese valores en la matriz "));
}
for(int x=0; x<n; x++) {
{
matrizImpresa+= matriz[x][y]+" ";
}
matrizImpresa+= "n";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa + "n");
}
public void buscarDiagonal(){
while (conta < n)
{
diagonal+= matriz[conta][conta]+" ";
diagonal+= "n";
conta ++;}
JOptionPane.showMessageDialog(null,"La diagonal es: n"+ diagonal);
}

96
public static void main (String args[]){
ImprimirDiagonal arreglo= new ImprimirDiagonal();
arreglo.crearMatriz();
arreglo.buscarDiagonal();
}
}

97
* @(#)OrdenarDiagonal.java
* @ Este programa lee una matriz e imprime su diagonal principal ordenada
*/
public class OrdenarDiagonal{
public OrdenarDiagonal(){}
int n = Integer.parseInt (JOptionPane.showInputDialog (" Inserte el número de filas y columnas"));
int diagonal= 0;
public void crearMatriz1() {
String matrizImpresa2="";
int [][] matriz1;
matriz1= new int [n][n];
{
matriz1 [x] [y]=Integer.parseInt (JOptionPane.showInputDialog ("Ingrese valores en la matriz"));
}
for(int x=0; x<n; x++){
for(int y=0; y<n; y++){
matrizImpresa+= matriz1 [x] [y]+" ";
}
}
for (int conta=0; conta< n-1; conta++)
for (int conta2=conta+1; conta2 < n; conta2++){
if ( matriz1[conta][conta]>matriz1 [conta2][conta2]){
diagonal= matriz1 [conta] [conta];
matriz1[conta][conta]= matriz1[conta2][conta2];
matriz1[conta2][conta2]= diagonal;
}
}

98
matrizImpresa2+= matriz1 [x][y]+" ";
}
matrizImpresa2+= "n";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa +"nCon la diagonal
ordenada "
+ "la matriz esn" +matrizImpresa2 );
}
OrdenarDiagonal arreglo= new OrdenarDiagonal();
arreglo.crearMatriz1();
}
}

100
* @ Este programa lee una matriz y la convierte en un vector de acuerdo al orden
* de filas y un vector de acuerdo al orden de columnas
*/
public class FilasColumnas{
public FilasColumnas(){}
int m = Integer.parseInt (JOptionPane.showInputDialog (" Inserte el número de filas"));
int n = Integer.parseInt (JOptionPane.showInputDialog (" Inserte el número de columnas"));
int [][] matriz1;
matriz1= new int [m][n];
int vector[]= new int [m*n];
int vector2[]= new int [m*n];
String vectorImpreso= "";
String vectorImpreso2= "";
int conta=0;
for(int x=0; x<m; x++)
{
matriz1 [x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Ingrese valores en la matriz"));
}
for(int x=0; x<m; x++){
matrizImpresa+= matriz1 [x][y]+" ";
vector[conta]=matriz1 [x][y];
conta ++;
}
}

101
conta=0;
for(int y=0; y<m; y++){
vector2[conta]=matriz1 [y][x];
conta ++;
}
}
for(int x=0; x<m*n; x++) {
vectorImpreso+= vector [x]+"n";
vectorImpreso2+= vector2 [x]+" ";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa
+"El vector por filas es: n"+vectorImpreso+"n El vector por columnas esn"+vectorImpreso2);
}
FilasColumnas arreglo= new FilasColumnas();
}
}

103
* @ Este programa lee una matriz e imprime su perímetro
*/
public class Perimetro {
public Perimetro(){}
int n[][];
int renglon;
int contadorFila=0;
int contadorY=0;
int contadorX=0;
String perimetro="";
renglon=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de renglones y columnas"));
n= new int [renglon] [renglon];
////////////////////////////Rellena e imprime la matriz/////////////////
for (int y=0; y<renglon; y++) {
n[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Ingrese valores en la matriz"));
}
matrizImpresa+="n";
}
///////////////////////////Obtiene el perímetro////////////////////////////
while (contadorFila < renglon){
if (contadorFila== 0){
while (contadorY<renglon){
contadorX=0;
perimetro+=n[contadorX][contadorY]+" ";
contadorY++;
}
perimetro+="n";
}

104
if (contadorFila== renglon-1){
while (contadorY<renglon){
contadorX= renglon-1;
perimetro += n[contadorX][contadorY]+" ";
contadorY++;
}
perimetro += "n";
}
if (!(contadorFila==0||contadorFila==renglon-1)){
contadorX=contadorFila;
int i=0;
while (i<renglon -2){
perimetro+=" ";
i++;
}
contadorY=contadorY + (renglon-1);
perimetro+="n";
}
contadorX=0;
contadorY=0;
contadorFila++;
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa
+"nEl perímetro es: n"+perimetro);
}
Perimetro result= new Perimetro();
result.leerHacer();
}
}

106
* @ Este programa lee una matriz y ordena las filas en de menor a mayor
* y las columnas de mayor a menor
*/
public class OrdenarFilasColumnas{
public OrdenarFilasColumnas(){}
int matrizFilas[][];
int matrizColumnas[][];
int aux;
String matriz="";
String matriz2="";
String matriz3="";
renglon=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de renglones"));
columna=Integer.parseInt (JOptionPane.showInputDialog ("Escriba el total de columnas"));
matrizFilas = new int [renglon] [columna];
matrizColumnas= new int [renglon] [columna];
////////// Rellena la matriz y la guarda para imprimir////////////////////
matrizFilas[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el elemento
del arreglo"));
matrizColumnas[x][y]=matrizFilas[x][y];
matriz+= matrizFilas[x][y] + " ";
}
matriz+="n";
}
//////////////Ordena las filas en orden descendente///////////////////////
for (int y=0; y <columna-1; y++) {
if(matrizFilas[x][y]>matrizFilas[x][y+1]) {
aux=matrizFilas[x][y];
matrizFilas[x][y]=matrizFilas[x][y+1];
matrizFilas[x][y+1]=aux; }
}
}

107
////////////////////Ordena las columnas en orden
ascendente///////////////////////////////////////
for(int x=0; x<columna; x++){
for(int y=0; y<renglon-1; y++){
if(matrizColumnas[y][x]<matrizColumnas[y+1][x]) {
aux=matrizColumnas[y][x];
matrizColumnas[y][x]=matrizColumnas[y+1][x];
matrizColumnas[y+1][x]=aux; }
}
}
////////////////////Guarda la matriz de filas y de columnas ordenadas para imprimir///////////
matriz2+= matrizFilas[x][y] + " ";
matriz3+= matrizColumnas[x][y]+" ";
}
matriz2+="n";
matriz3+="n";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matriz+"nLa matriz con filas ordenadas
esn"
+matriz2+"nLa matriz con las columnas ordenadas esn"+matriz3);
}
OrdenarFilasColumnas result= new OrdenarFilasColumnas();
result.leerHacer();
}
}

109
//Programa que lee una matriz A, una Matriz B, multiplica la Matriz A por la matriz B y guarda
// los resultados en una matriz C para después imprimir las tres Matrices.
public class MatrizMultiplicacion{
public MatrizMultiplicacion (){}
int totfilasA;
int totcolumnasA;
int totfilasB;
int totcolumnasB;
int matrizA[][];
int matrizB[][];
int matrizC[][];
String A="";
String B="";
String C="";
public void crearDatos(){
totfilasA= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de filas de la matriz A"));
totcolumnasA= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de columnas de la matriz
A"));
totfilasB= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de filas de la matriz B"));
do{
if (totcolumnasA!=totfilasB){
totfilasB= Integer.parseInt(JOptionPane.showInputDialog("El número de filas de la matriz B debe ser igual "+
"al número de columnas de la matriz AnIngrese nuevamente el número de filas de la matriz B"));
}
}while (totcolumnasA!=totfilasB);
totcolumnasB= Integer.parseInt(JOptionPane.showInputDialog("Ingrese el número de columnas de la matriz
B"));
matrizA= new int [totfilasA][totcolumnasA];
matrizB= new int [totfilasB][totcolumnasB];
matrizC= new int [totfilasA][totcolumnasB];
}
/////////////////////////////ABRE METODO LEER MATRICES//////////////////////////
public void leerMatrices(){
for ( int filasA = 0; filasA < totfilasA; filasA++){
for ( int columnasA = 0; columnasA < totcolumnasA; columnasA++){
matrizA[filasA][columnasA]=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento ["
+filasA+"]["+columnasA+"] de la matriz A"));
}
}

110
/////////////////////////////////////////////////////////////////////////////////
for ( int filasB = 0; filasB < totfilasB; filasB++){
for ( int columnasB = 0; columnasB < totcolumnasB; columnasB++){
matrizB[filasB][columnasB]=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el elemento ["
+filasB+"]["+columnasB+"] de la matriz B"));
}
}
}
////////////////////////////ABRE METODO MULTIPLICAR////////////////////////////
public void Multiplicar(){
for ( int j = 0; j < totfilasA; j++){ // controla el orden en que se debe trabajar con las filas
for ( int k = 0; k < totcolumnasB; k++){// las columnas se usan más y se reinician después de que se termina con
una fila de A
// por eso va dentro del for de filas de A
for ( int i = 0; i < totfilasB; i++ ){// también se podria usar el total de columnas de A como
condición
// para entrar al for pues los valores de columnas de A y filas de B
// son iguales
matrizC[j][k] += matrizA[j][i]*matrizB[i][k];
// un elemento de una fila de A se multiplican con un elemento de una columnas de B
// cuando todos los elementos de una fila de A se han multiplicado con todos los elementos
de una columna de B
// según el orden que controla i, los resultados se van sumando y guardando en un elemento
de una fila de la matrizC
// es por eso que j aumenta mas lento que K, ya que K lleva la cuenta de las columnas que se
deben crear
// en C.
}
}
}
}
/////////////////////////////ABRE METODO IMPRIMIR MATRICES//////////////////////////
public void imprimirMatrices(){
for ( int filasA = 0; filasA < totfilasA; filasA++){
for ( int columnasA = 0; columnasA < totcolumnasA; columnasA++){
A+=matrizA[filasA][columnasA]+" ";
} A+= "n";
}

111
/////////////////////////////////////////////////////////////////////////////////
for ( int filasB = 0; filasB < totfilasB; filasB++){
for ( int columnasB = 0; columnasB < totcolumnasB; columnasB++){
B+=matrizB[filasB][columnasB]+" ";
}B+= "n";
}
//////////////////////////////////////////////////////////////////////////////////
for ( int filasC = 0; filasC < totfilasA; filasC++){
for ( int columnasC = 0; columnasC < totcolumnasB; columnasC++){
C+=matrizC[filasC][columnasC]+" ";
}C+= "n";
}
//////////////////////////////////////////////////////////////////////////////////
JOptionPane.showMessageDialog(null,"La matriz A es: n"+A+"n La matriz B es: n"+B+"El producto de A X B
es: n"+C);
}
///////////////////////////////////////////////////////////////////////////////
public static void main (String[]args){
MatrizMultiplicacion Multi= new MatrizMultiplicacion();
Multi.crearDatos();
Multi.leerMatrices();
Multi.Multiplicar();
Multi.imprimirMatrices(); }
}//cierra clase

113
* @ Este programa lee una matriz bidimensional e imprime su transpuesta
*/
public class Trans{
public Trans(){}
int original[][];
int transpuesta[][];
String originalImpresa="";
String transpuestaImpresa="";
original= new int [renglon] [columna];
transpuesta= new int [columna][renglon];
original[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el
elemento del arreglo"));
originalImpresa+="["+original[x][y]+"] ";
}
originalImpresa+="n";
}
for (int x=0; x<columna; x++) {
for (int y=0; y <renglon; y++) {
transpuesta[x][y]=original[y][x];
transpuestaImpresa+=transpuesta[x][y] + " ";
}
transpuestaImpresa+="n";
}
JOptionPane.showMessageDialog(null,"La matriz original es:n"+originalImpresa+"nLa matriz
transpuesta es:n"+transpuestaImpresa);
}

114
Trans result= new Trans ();
result.leerHacer();
}
}

115
* @ Este programa lee una matriz bidimensional y cambia las diagonales
* principales
*/
public class DiagonalInversa{
public DiagonalInversa(){}
int n = Integer.parseInt (JOptionPane.showInputDialog (" Inserte el número de filas y columnas"));
int aux= 0;
String matrizImpresa2="";
int [][] matriz1;
matriz1= new int [n][n];
///////////////////LEE LA MATRIZ///////////////////////////
{
matriz1 [x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Ingrese valores en la
matriz"));
}
matrizImpresa+= matriz1 [x] [y]+" ";
}
}
///////////////////INVIERTE LAS DIAGONALES Y GUARDA LA NUEVA MATRIZ////////////////
int y= n-1;
for (int x=0; x< n; x++){
aux= matriz1 [x][x];
matriz1[x][x]= matriz1[x][y];
matriz1[x][y]= aux;
y--;
}

116
for( y=0; y<n; y++){
matrizImpresa2+= matriz1 [x][y]+" ";
}
matrizImpresa2+= "n";
}
JOptionPane.showMessageDialog(null,"La matriz es: n"+matrizImpresa +"nCon la diagonal
inversa "
+ "la matriz es:n" +matrizImpresa2 );
}
DiagonalInversa arreglo=new DiagonalInversa();
}
}

118
* @ Este programa lee una matriz bidimensional e imprime la matriz
* simetrica basandose en los valores de arriba de la diagonal
*/
public class TriangularSuperior{
public TriangularSuperior(){}
int n[][];
int simetrica[][];
int aux;
String original="";
String simetricaImpresa="";
simetrica= new int [columna][renglon];
n[x][y]=Integer.parseInt (JOptionPane.showInputDialog ("Introduzca el elemento["+x+"]["+y+"]
del arreglo"));
original+= n[x][y]+" ";
}
original+= "n";
}
for (int y=x; y <columna; y++) {
simetrica[y][x]=n[x][y];
}
}

119
int y=0;
for ( y=x; y <columna; y++) {
simetrica[x][y]=n[x][y];
}
}
for ( y=0; y <columna; y++) {
simetricaImpresa+=simetrica[x][y] + " ";
}
simetricaImpresa+="n";
}
JOptionPane.showMessageDialog(null,"La matriz original es: n"+original+"nLa matriz simetrica
esn"
+simetricaImpresa);
}
TriangularSuperior result= new TriangularSuperior ();
result.leerHacer();
}
}

121
ANEXOS
Algoritmo Pseudocódigo
1.-Leer n
2.- conta=2
3.-contaP=0
4.-if conta <=n
Si------------------------- ir al paso 5
No----------------------- ir al paso 8
5.- contaP= contaP+1
6.-conta= conta + 2
7.-Ir al paso 4
8.-Fin
Int n,conta,contaP
conta=2;
contaP=0;
1.-Leer n
2.-while(conta <=n) {
contaP=contaP+1;
conta=conta +2;}
3.-Fin
Int n,conta,contaP
conta=2;
contaP=0;
1.-Leer n
2.- do
contaP=contaP+1;
conta=conta +2;
while (conta <=n);
3.-Fin
Int n,conta,contaP
conta=2;
contaP=0;
1.-Leer n
2.-for(conta=2;conta <=n;conta=conta+2;) {
contaP=contaP+1;
}
3.-Fin

122
1.- Leer n
2.- contaAlum= contaAlum +1
3.- Leer calif
4.-sumaCalif=sumaCalif + calif
5.-if contaAlum < n
Si------------------------------- ir al paso
2
No ------------------------------ir al paso
6
6.- promGen= sumaCalif /n
7.-Imprimir “el promedio general es” ;
promGen
8.-Fin.
Int n,contaAlum, calif,sumaCalif,promGen
contaAlum=0;
sumaCalif=0;
promGen=0;
1.- Leer n
2.-While (contaAlum < n){
Leer calif;
}
3.-promGen= sumaCalif /n;
4.-Imprimir “el promedio general es” ; promGen
5.-Fin.
contaAlum=0;
sumaCalif=0;
promGen=0;
1.- Leer n
2.- do
Leer calif;
while (contaAlum < n)
5.-Fin.
contaAlum=0;
sumaCalif=0;
promGen=0;
1.- Leer n
2.for(contaAlum=0;contaAlum<n;contaAlum+1){
Leer calif;
}

123
5.-Fin.
1.- Leer n
2.- Leer “ total de materias”; totMat
3.- If (totMat >= 1) && (totMat<=4)
Si------------------- ir al
paso 4
No-----------------
“error”
4.- Leer calif
5.-sumaCalif= sumaCalif + calif
7.- if (contaMat<= totMat)
Si---------------------- ir
al paso 4
No--------------------- ir
al paso 8
8.- promInd=sumaCalif/totMat
9.-acumProm= acumProm + promInd
10.- contaAlum= contaAlum + 1
11.- if conta Alum <= n
Si------------------------------
ir al paso 2
No-----------------------------
ir al paso 12
12.- promGen= acumProm /n
13.- Imprimir “el promedio general es ”;
promGen
14.-Fin
Int n, calif,sumaCalif,contMat, totMat, promInd,
acumProm, contaAlum, promGen
sumaCalif=0
contMat=1
acumProm=0
contaAlum=1
totMat=0;
1.- Leer n
2.-while (contaAlum<=n) {
while (!(totMat >= 1) && !(totMat<=4)) {
“Introduzca ”
Leer “ total de materias”; totMat
}
while (contaMat<=totMat) {
Leer calif
}
}
3.-promGen= acumProm/n;
4.-imprimir “ el promedio general es”; promGen
5.-Fin

124
sumaCalif=0
contMat=1
acumProm=0
contaAlum=1
totMat=0;
1.- Leer n
2.- do {
do
{Leer “ total de materias”; totMat
} while (!(totMat >= 1) && !(totMat<=4));
do
{Leer calif
}while (contaMat<=totMat);
}while (contaAlum<=n) ;
5.-Fin

125
sumaCalif=0
contMat=1
acumProm=0
contaAlum=1
totMat=0;
1.- Leer n
2.-for(contaAlum=1;
contaAlum<=n;contaAlum=contaAlum +1;){
for (totMat=0;!(totMat >= 1)&& !(totMat<=4) ;
;) {
“Introduzca ”
Leer “ total de materias”; totMat }
for(contaMat=0;
contaMat<=totMat;contaMat=contaMat+1;)
{ Leer calif
}
}
5.-Fin

126
1.- Inicio
2.- Leer n
3.- auxiliar= n-1
4.- factorial= n * auxiliar
5.- if (auxiliar=1)
Si ir al paso 9
No ir al paso 6
6.- auxiliar= auxiliar – 1
7.- factorial= factorial * auxiliar
8.- Volver al paso 5
9.- Imprimir “El factorial es”; factorial.
10.- Fin
int n, factorial, auxiliar
1.- Leer n
2.- auxiliar= n-1
3.- factorial= n* auxiliar
4.- while (auxiliar !=1){
}
5. Imprimir “El factorial es”; factorial
6.-Fin
1.- Leer n
2.- auxiliar= n-1
4.- do
while (auxiliar !=1);
6.-Fin
1.- Leer n
2.- auxiliar= n-1
4.-for (auxliar= n-1; auxiliar !=1;
auxiliar=auxiliar-1;) {
}
6.-Fin

127
1.- Leer n
2.- antecesor=0
3.- sucesor=1
4.- Imprimir sucesor
5.- if !(suma>=n)
Si ir al paso 6
No ir al paso 11
6.- suma=antecesor + sucesor
7.-Imprimir “ “; suma
8.- antecesor=sucesor
9- sucesor=suma
10.- Regresar al paso 5
11.-Fin
int n, antecesor, sucesor, suma
antecesor=0;
sucesor=1;
suma=0;
1.- Leer n
2.- Imprimir “”; sucesor
3.- while(!(suma>=n)){
suma=antecesor + sucesor;
Imprimir “ “; suma
antecesor=sucesor;
sucesor=suma ; }
4.- Fin
antecesor=0;
sucesor=1;
suma=0;
1.- Leer n
3.- do
suma=antecesor + sucesor;
Imprimir “ “; suma
antecesor=sucesor;
sucesor=suma ;
while(!(suma>=n));
4.- Fin
antecesor=0;
sucesor=1;
suma=0;
1.- Leer n
3.- for(suma=antecesor + sucesor;!(suma>=n);
suma=antecesor + sucesor;)
{ Imprimir “ “; suma
antecesor=sucesor;
sucesor=suma ; }

128
4.- Fin
contaAlum=0
contaMat=0
1.-Leer n
2.- contaAlum= contaAlum +1
3.- if contaAlum <= n
Si----------- ir al paso 4
No------------------ir al paso 11
4.- Leer“Nombre del alumno”;nomAlum
5.- Leer”Total de materias”; totMat
7.- if contaMat<=totMat
Si------------------------------ ir al
paso 8
No-------------------------------- ir al
paso 2
8.- Leer “Su materia “;contaMat; “es “;
nomMat
9.- Leer “La calificación de la materia “;
nomMat; “ es “; calif
10.- Ir al paso 6
11.- Fin
int contaAlum, totMat,contaMat,calif
string nomAlum, nomMat
contaAlum=1
contaMat=1
1.-Leer n
3.- while (contaAlum <= n){
7.- while( contaMat<=totMat)
{
Leer “Su materia “;contaMat; “es “;
nomMat
Leer “La calificación de la materia “;
}
contaAlum= contaAlum +1}
10.- Ir al paso 6
11.- Fin

129
contaAlum=1
contaMat=1
1.-Leer n
2.- do{
5.- do
{
nomMat
} while( contaMat<=totMat);
contaAlum= contaAlum +1
} while (contaAlum <= n);
6.- Fin

130
contaAlum=1
contaMat=1
1.-Leer n
2.- for(contaAlum=1; contaAlum <=n;
contaAlum=contaAlum+1;)
{
Leer“Nombre del alumno”;nomAlum
Leer”Total de materias”; totMat
for (contaMat=1;
contaMat<=totMat;contaMat=contaMat+1;)
{
nomMat
}
}
3.- Fin

Fundamentos de programacion

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Fundamentos de programacion

Ähnlich wie Fundamentos de programacion (20)

Mehr von Benjamín Joaquín Martínez

Mehr von Benjamín Joaquín Martínez (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Fundamentos de programacion