Módulo Algoritmia y Programación

Tabla de Contenido
Expresiones 3
Expresiones aritméticas 3
Operadores aritméticos 3
Expresiones Lógicas 5
Operadores relacionales 5
Operadores lógicos 6
Operaciones matemáticas 8
Introducción a la Programación 10

Actividad 1 : Análisis 12
Actividad 2: Diseño 15
Actividad 3: Implementación 18
Elementos básicos de programación 18
Variables 18
Constantes 20
Operador de asignación 20
Expresiones 21
Operaciones 21
Método 21
Actividad 4: Pruebas 22
Introducción al Lenguaje C# 23
Estructura General: 25
Operaciones: 25
Lectura de variables de entrada desde una GUI. 25
Escritura (salida) de variables de entrada desde una GUI. 26
Programación Estructurada 28
Estructuras de decisión 28
Diagrama de flujo 28

Sintaxis en C# 29
Estructura de Decisión Múltiple 31
Sintaxis en C# 32
Estructuras de Repetición 35
La estructura 35
Forma 1: Ciclo FOR 40
Forma 2: Ciclo WHILE 46
Forma 3: Ciclo DO - WHILE 51
Métodos 62
Elementos 62
Diseño (flujograma) 63
Sintaxis en C# 64
Invocación o llamado al método 70
Estructuras Estáticas 72
Arreglos 72
Arreglos Unidimensionales (Vectores) 73
Operaciones sobre arreglos unidimensionales 74
Declaración 74
Inicialización de un Arreglo 78
Arreglos Bidimensionales (Matrices) 87
Operaciones sobre arreglos bidimensionales (Matrices) 88
Declaración 88
Inicialización 89
Recorrido de una matriz 91
Curso: Algoritmia y Programación 1

Escrito por: Lyda Peña.



ALGORITMIA Y PROGRAMACIÓN

I. Expresiones
Se entiende como expresiones, sentencias que involucran el uso de
constantes, variables y operadores. Las expresiones se clasifican de acuerdo
al tipo de datos y operadores que emplean, lo cual implica también el tipo de
resultado que se obtiene en su desarrollo o evaluación.

Expresiones aritméticas
Una expresión aritmética es aquella que incluye variables numéricas (enteras o
reales), constantes numéricas y operadores aritméticos.
Operadores aritméticos
+ Operador de suma
- Operador de resta
* Operador de multiplicación
/ Operador de división
Algunos lenguajes pueden emplear otros símbolos para representar las


diferentes operaciones o pueden incluir nuevos operadores como el de

módulo o residuo.
Prioridad: Un aspecto importante para revisar cuando se estudian los
operadores aritméticos en cada lenguaje es la prioridad. La prioridad
corresponde a las reglas que indican cuál operación debe realizarse primero
en una expresión aritmética; aunque estas reglas pueden variar de un lenguaje
a otro, en general la mayor prioridad la tienen los operadores de
multiplicación y división, después seguirán los de suma y resta.
Cuando se encuentran dos o más operadores del mismo nivel de prioridad, las

operaciones se resuelven de izquierda a derecha.
El uso de paréntesis permite saltar las reglas de prioridad para obligar a que se
desarrolle una operación primero, dado que las operaciones incluidas en
paréntesis tendrían la mayor prioridad en la expresión.
Ejemplo:

4+8*2–6/2 Para resolver esta expresión se realizaría primero

la multiplicación 8*2 (=16), luego la división 6/2
(=3), luego la suma 4 + 16 (=20) y finalmente la
resta 20 – 3, dando como resultado 17.
(4 + 8) * (2 – 6) / 2 En este caso se ha alterado la prioridad gracias al

uso de paréntesis, aquí se realiza primero la suma
4+ 8 (=12), luego la resta 2-6 (=-4), luego la
multiplicación 12 * -4 (=-48) y finalmente la
división -48 / 2 dando como resultado -24.
Como se puede observar en el ejemplo anterior, el uso de paréntesis cambia
completamente el resultado de una expresión, así que debe tenerse mucho
cuidado al momento de escribir expresiones aritméticas para verificar que las


prioridades harán que se tenga el resultado que realmente se espera.

Observe que: En los lenguajes de programación, se tiene muy en cuenta los
tipos de datos empleados en las operaciones, aunque puede variar, en
términos generales si se operan números enteros (sin parte decimal) el
resultado será un número entero; pero si se operan números reales (que
incluyen parte decimal) o una combinación entre reales y enteros, el resultado
será un número real.
Considerando lo anterior, el resultado de operaciones como la división puede
variar, así:
10 / 4 dará como resultado 2 , ya que los dos números son enteros

a que los números son reales.
10.0 / 4.0 dará como resultado 2.5, y

Expresiones Lógicas
Las expresiones lógicas pueden emplear datos de diferentes tipos (lógicos o
numéricos), emplean operadores lógicos o relacionales y obtienen como
resultado un valor lógico (verdadero o falso).

Operadores relacionales
Estos operadores son los que permiten establecer algún tipo de relación entre

dos operandos, las relaciones comunes son las siguientes:

Relación Operador
Igual ==
Diferente !=
Mayor >
Menor <
Mayor o igual >=
Menor o igual <=

Los operandos (datos]) que se pueden emplear, en general corresponden a
números, aunque algunos lenguajes permiten comparar otro tipo de datos
como caracteres o cadenas.
El resultado de una operación que involucra operadores relacionales será de
tipo lógico (verdadero o falso)

Ejemplo:

3>4 tendrá como resultado Falso
5 < 20 tendrá como resultado verdadero
10 >= 10 Tendrá resultado Verdadero

3 < 4 < 10 no es una expresión válida porque en algún
momento quedaría algo como verdadero < 10, lo
cual no puede resolverse.

Operadores lógicos
Los operadores lógicos permiten enlazar expresiones lógicas a través de las
conexiones lógicas que se emplean comúnmente. Los operadores lógicos
comúnmente empleados son:

Conexión lógica Operador Símbolo en C#
Conjunción AND &&
Disyunción OR ||
Negación NOT !

Estos operadores trabajan siguiendo la lógica de las tablas de verdad que se
presentan a continuación:

AND Verdadero Falso
Verdadero Verdadero Falso
Falso Falso Falso

Observe que: para la conjunción (AND) el único caso en que puede ser
verdadero, es que las dos partes de la expresión sean verdaderas, cualquier
otra combinación sería falsa.

OR Verdadero Falso

Verdadero Verdadero Verdadero

Falso Verdadero Falso
Observe que: para la disyunción (OR) el único caso en que puede ser falso, es
que las dos partes de la expresión sean falsas, cualquier otra combinación
sería verdadera.

NOT
Verdadero Falso
Falso Verdadero

El operador de Negación trabaja sobre un único operando, cambiando su valor
de verdad (o valor lógico).
Ahora bien, regresando al tema de las expresiones lógicas, estas podrían
involucrar solamente operadores lógicos, operadores relacionales o
combinación de ambos; dependiendo de lo que se quiera presentar.

Ejemplo:

Si se quiere verificar que la variable nota se encuentra en el rango [0.0, 5.0] la
expresión correcta sería:
( Nota >= 0.0 ) && (nota <=5.0)

En este caso, se resuelven primero las expresiones en paréntesis, de la
siguiente forma.

Si la variable Nota obtiene el valor de 2.6 tendríamos:
( 2.6 >= 0.0 ) && (2.6 <=5.0)
Verdadero && verdadero
Verdadero

Si la variable Nota obtiene el valor de 6.2 tendríamos:
( 6.2 >= 0.0 ) && (6.2 <=5.0)
Verdadero && Falso
Falso

Al combinar operadores lógicos y aritméticos, las prioridades establecidas
varían, quedando dela siguiente forma:

!
/ * %
+ -
> < >= <=

== !=
&&
||
Como siempre, los paréntesis permiten saltar los niveles de prioridad.

Ejemplo:

Para el siguiente caso:

3 + 4 < 10 && 56 – 3 > 100 || 4 * 6 -2 <=22

La solución, atendiendo las prioridades establecidas, quedaría de la siguiente
forma:
1. Se resuelven divisiones y multiplicaciones:
3 + 4 < 10 && 56 – 3 > 100 ||24 -2 <=22
2. Se resuelven sumas y restas (de izquierda a derecha):
7 < 10 && 53 > 100 ||22 <=22
3. Se resuelven los operadores relacionales:
Verdadero && Falso || Verdadero
4. Se resuelven las operaciones de conjunción (AND, &&)
Falso || verdadero
5. Se resuelven las operaciones disyunción (OR, ||)
Verdadero

La solución de la expresión es: Verdadero.

Operaciones matemáticas
Algunas operaciones matemáticas comunes, no tienen representación en los

lenguajes de programación como un operador, en lugar de ello debe
emplearse un método que ya está incorporado en el lenguaje. En el caso de
C#, muchas de estas operaciones se incorporan en la clase Math, entre las
más comunes se encuentran las siguientes:

Nombre del método Función
Cos(double x) Retorna el coseno del ángulo especificado.
Exp (double x) Retorna e elevado a la potencia especificada.
Log (double x) Devuelve el logaritmo natural (en base e) de un número
especificado.
Log10(double x) Devuelve el logaritmo en base 10 de un número

especificado.
Pow(double x, double y) Retorna un número (x) elevado a la potencia especificada
(y)
Round (decimal x) Redondea un número decimal al entero más próximo.
Sin (double x) Retorna el seno del ángulo especificado.
Sqrt(double x) Retorna la raíz cuadrada del número indicado.
Tan(double x) Retorna la tangente del ángulo especificado.

Para emplear cualquiera de estas funciones se debe anteponer Math. al
nombre del método correspondiente, esto le especifica al lenguaje que el
método que se desea usar está en una clase llamada Math.

Ejemplo:

X = Math.sqrt(64);

Esta expresión dejaría en x el valor de 8 (raíz cuadrada de 64)

Estos métodos pueden ser involucrados dentro de una expresión.

Ejemplo:

58 – Math.sqrt(64) < 100

En este caso, se resuelve primero el método, luego la resta y finalmente la
comparación; lo que daría como resultado Verdadero



II. Introducción a la Programación

Un algoritmo, se define como “un conjunto ordenado y finito de operaciones
1
que permite hallar la solución de un problema” . Si se lee con atención la
definición, no se mencionan computadores, lenguajes de programación o
dispositivos de procesamiento alguno y esto es debido a que el énfasis de un
algoritmo no está en la programación de computadores sino en la definición
de los pasos o instrucciones, que deben ser claros y completos para permitir
alcanzar un objetivo.
Además del proceso definido (pasos), los algoritmos tienen otros dos
elementos que los caracterizan: las entradas y la(s) salida(s). Las entradas o
elementos de entrada o datos de entrada son aquellas cosas o datos que se
requieren para poder realizar el algoritmo a cabalidad. La salida son los
elementos o datos que se obtienen una vez se ejecuten los pasos del
algoritmo.
La diferencia básica entre un algoritmo y un programa es que este último
está escrito en un lenguaje de programación, de forma que pueda ser
interpretado y ejecutado por un computador.
-Escribir un programa, implica necesariamente, hacer un algoritmo-
Cuando vamos a programar, nuestro cerebro ejecuta la misma secuencia de
pasos que aplica en cualquier situación problemática: primero, entender el
problema con todas sus condiciones y características; segundo, buscar una
solución que se ajuste a dichas condiciones y características; tercero, poner en
ejecución la solución hallada; cuarto, verificar si la solución cumple con lo que
2
se indicó que debería hacer .
1
Real Academia Española. Diccionario. 2015. Disponible en: http://www.rae.es/recursos/diccionarios/drae [consultado: Julio 20 de
2015]
2
En desarrollo de software, esta característica se conoce como corrección, un algoritmo correcto, es un algoritmo que efectivamente
cumple lo que se supone que debería hacer.

Ejemplo:

Tenemos una situación problema: “Es necesario llegar desde la UAO hasta
Chipichape”.
Primero: entendamos el problema, es claro hay que encontrar una forma de
llegar desde la UAO hasta Chipichape, pero hay algunas restricciones que
tenemos que considera: ¿hay restricción de dinero para el transporte? ¿hay
restriccion de tiempo para el transporte? ¿cuántas personas deben
transportarse?
Digamos que debemos transportar a 3 personas, no importa cuánto tiempo se

demoren pero no deberían gastar más de $10.000.
Ahora sí, teniendo claro el problema, entramos al paso dos: buscar alternativas
de solución.
● Alternativa 1: Tomar un taxi. Permite transportar a 3 personas pero con seguridad

costaría más de 10.000 pesos. ¡Descartada!
● Alternativa 2: Ir en MIO. Permite transportar a 3 personas y cuesta menos de 10.000
pesos. ¡es una alternativa válida!
● Alternativa 3: Ir caminando. Permite el transporte de 3 personas y cuesta menos de
10.000 pesos. ¡es una alternativa válida!
Una vez encontramos alternativas válidas podemos seleccionar una, vamos a

seleccionar la Alternativa 2, porque aunque la Alternativa 3 es más barata,
tardaría mucho tiempo y las personas llegan muy cansadas.
Una vez seleccionada la alternativa, procedemos al Tercer paso, implementar
la solución. En este caso, la implementación consiste en determinar cuáles
rutas del MIO se deberán tomar desde la UAO hasta Chipichape y en cuáles
estaciones se debe hacer cambio de ruta.
Antes de enviar a las tres personas a aventurarse por las calles de Cali,
podemos adelantar el paso Cuatro: Probar la solución. Probar es verificar si

con las entradas que hemos definido y los pasos que se han establecido
logramos el resultado esperado; entonces, se puede hacer una revisión sobre
el mapa, para verificar si las rutas seleccionadas con intercambio en las
estaciones definidas permiten que las personas lleguen desde la UAO hasta
Chipichape.
Una vez se comprueba que la solución diseñada es apropiada, podemos
generalizar, cualquier persona que tenga el mismo problema con las mismas
restricciones, podrá utilizar nuestra solución.
Este es un ejemplo bastante simple, pero representa nuestra forma de pensar

y actuar ante cualquier situación problema, lo que sucede es que no siempre
somos conscientes de este proceso, nuevamente, porque lo tenemos tan
interiorizado y lo realizamos de forma tan automática que no lo pensamos
paso por paso; sin embargo, si lo piensas por un minuto, ante cualquier
situación actuas de la misma forma, bueno, con algunas variaciones, porque
algunas situaciones requieren que la etapa uno sea de mayor duración que las
otras, pero otras situaciones requieren que la etapa dos sea la de mayor
duración, etc.
Estas mismas etapas son las que seguiremos en la elaboración de algoritmos,
lo que sucede, es que como todo proceso en Ingeniería, tiene sus
particularidades en la forma de realizarlo y comunicarlo.
Actividad 1 : Análisis
La primera etapa en el proceso de programación tiene diferentes nombres, en

nuestro caso, la denominaremos Análisis, en esta etapa se busca comprender
la funcionalidad del programa, así como identificar las restricciones que se
tengan sobre la operación del mismo.
Otra forma de comprender la etapa de análisis es preguntarse ¿Qué debe
hacer el programa? y ¿Qué condiciones se deben cumplir durante la ejecución

para lograrlo?
Ahora, ¿De dónde se obtiene esa información?, la respuesta es muuuy simple,
de la persona que necesita el programa. Durante el proceso de aprendizaje, es
común que los profesores entreguen por escrito la definición del problema, y
de allí básicamente se obtiene la información que se requiere. En situaciones
reales, debe preguntarse a la(s) persona(s) que requieren el programa sobre
todos los aspectos que este deberá incluir.
Para efectos del curso, en la etapa de análisis se establecerán los datos de
entrada y los datos de salida.
● Datos de entrada: Son aquellos datos que se requiere conocer para
que el programa pueda funcionar apropiadamente. Generalmente se
asocian con las “cosas” que se preguntará al usuario.
Un buen programador es consciente que al preguntar un dato, el
usuario puede contestar de cualquier forma, por ello, debe asegurar
que la información ingresada sea apropiada para el desarrollo del
programa, para ello se emplea la validación de datos, por ahora
solamente nos centraremos en establecer cuáles son los valores válidos
para un dato de entrada, más adelante veremos cómos se hace la
validación.
● Datos de salida: Corresponden a los datos o información que el
usuario espera que el programa le presente.
Ejemplo:

En la Universidad de la Región se quiere desarrollar un programa que permita

determinar rápidamente si un estudiante ha perdido una asignatura por
inasistencia y en cualquier caso, su nota definitiva. Para esto debe tenerse en
cuenta que un estudiante pierde una asignatura si ha faltado al 20% o más de
las horas programadas en un curso, en ese caso, su nota definitiva será 1.5; de
otra forma, su nota se calcula como el promedio de cuatro exámenes que se
presentan durante el semestre.


● Datos de Entrada: Para el desarrollo del programa, es necesario
conocer los siguientes datos:
○ Número de horas totales programadas en el curso.
○ Número de horas que ha faltado el estudiante
○ Calificación del primer examen
○ Calificación del segundo examen
○ Calificación del tercer examen
○ Calificación del cuarto examen
Los dos primeros datos permitirán calcular el porcentaje de faltas que
ha tenido el estudiante y de esta manera determinar su nota; si no ha
perdido la asignatura por faltas, los otros cuatro datos permitirán hacer
el cálculo de la definitiva.
Observe que datos como el porcentaje que determina que el
estudiante ha perdido la asignaturas por faltas o la nota que se asigna
en caso de pérdida por faltas, no se incluyen en los datos de entrada
porque ya se conocen (20% y 1.5 respectivamente).
Para efectos posteriores de validar los datos, vamos a incluir el rango de

valores válidos para cada dato:
○ Número de horas totales programadas en el curso. (mayor a 0)

○ Número de horas que ha faltado el estudiante (mayor o igual a 0)
○ Calificación del primer examen (entre 0.0 y 5.0)
○ Calificación del segundo examen(entre 0.0 y 5.0)
○ Calificación del tercer examen(entre 0.0 y 5.0)
○ Calificación del cuarto examen(entre 0.0 y 5.0)
● Datos de Salida: Al finalizar el programa se espera que se presente el
siguiente dato:
○ Nota definitiva del estudiante
Observe que: Aunque durante el proceso (programa) deberá calcularse el
porcentaje de inasistencias que ha tenido el estudiante, este dato no será


mostrado al usuario, por lo tanto no se considera dato de salida.

Actividad 2: Diseño
El diseño de un programa, es realmente el algoritmo del mismo y como tal,
contempla las tres secciones mencionadas: entradas, proceso y salidas. Las
entradas y salidas se definieron en el paso anterior, así que ahora nos
concentramos en el proceso.
Proceso: Se refiere a todas las instrucciones necesarias para que el
computador pueda cumplir el objetivo propuesto para el programa. Este
proceso debe describirse en forma de algoritmo, es decir pasos ordenados,
claros y completos que al ser seguidos de forma rigurosa permiten la
ejecución del objetivo propuesto.
Existen múltiples formas de representar el proceso de un algoritmo, se puede
hacer con lenguaje natural (español o inglés), con lenguaje estructurado
(pseudocódigo) o lenguaje gráfico (flujograma). Para nuestro caso se emplea
el flujograma, que tiene dos grandes ventajas: es estándar y es gráfico, lo que
permite mayor comprensión para los lectores.
FlujoGrama
Durante este curso se emplea la notación de flujograma o diagrama de flujo
para presentar el diseño de un programa. El flujograma es una representación
gráfica de las instrucciones que se llevarán a cabo en el programa. A
continuación se presentan los símbolos a emplear.
Símbolo Utilización
Inicio / Fin
Indica los extremos del proceso principal. Dentro del símbolo se deberá escribir la
palabra Inicio o Fin.

Si este símbolo es utilizado en un subproceso, en el Inicio se deberán escribir las

entradas, y en el Fin, se deberá escribir la salida.
Solamente deberá aparecer un símbolo de inicio y un símbolo de fin para cada


proceso.
Lectura de Datos
Este símbolo se emplea para especificar los datos que se deben leer o ingresar para la
ejecución del programa. Dentro del símbolo se escriben los datos a leer.

Proceso
Especifica los cálculos requeridos, tales como: evaluación de fórmulas, incrementos,
entre otros. Para cada cálculo se debe especificar la variable donde quedará
almacenado el valor .

Decisión
Este símbolo permite mostrar decisiones que se deben tomar durante la realización
del algoritmo, dentro del rombo se escribirá la pregunta o expresión lógica que genera
la decisión.
Este símbolo se puede emplear para tomar decisiones, en cuyo caso, saldrá del
símbolo dos caminos, uno marcado como SI y otro como NO, para indicar las
instrucciones que se deben realizar cuando la expresión sea verdadera o falsa,
respectivamente.

Salida
Se emplea este símbolo para indicar la información que se va a presentar al usuario.

Línea de Flujo
Indica la secuencia de las instrucciones. Debe tenerse cuidado que las flechas sean
rectas (horizontales o verticales) y que no se cruzan unas con otras en el diagrama.

Método
Con este símbolo se realiza la invocación o llamado a un subproceso, al interior del
cuadro se escribe el nombre del subproceso que se va a invocar.
Adicionalmente, se debe especificar los parámetros enviados al subproceso entre
paréntesis y la variable en la cual es asignado el valor que éste devuelve.
Conector
Este símbolo permite conectar varias flechas en la misma página.

Conector de página.
Si el diseño de un programa ocupa varias páginas, se puede emplear este conector
para indicar la secuencia de instrucciones, si existen varios conectores, es conveniente
enumerarlos para evitar alguna confusión.

Comentario
Este símbolo permite incluir comentarios o notas adicionales sobre el algoritmo. Se
sugiere utilizar este símbolo (junto al símbolo de Inicio) para incluir el nombre de los
procesos.

Ejemplo:

Continuando con nuestro ejemplo y considerando los datos de entrada y


salida definidos, pasaremos a desarrollar el diseño del mismo.
A manera de ejemplo, se presenta el siguiente diagrama como una propuesta
3
de solución :
NOTA: como todo proceso de diseño en Ingeniería, pueden presentarse
diferentes propuestas para la solución de un problema, sin embargo, debe
asegurarse que todos los pasos se cumplan y la salida sea la esperada.
3
Los flujogramas de ejemplo que se presentan en este documento, así como los que se presentarán posteriormente durante el curso,
han sido realizados empleando la herramienta Microsoft Visio 2010. Los estudiantes son libres de emplear esta u otra herramienta e
incluso hacer sus diagramas a mano, siempre y cuando respeten los símbolos definidos.

Actividad 3: Implementación
El siguiente paso es realizar la implementación del algoritmo, es decir, traducir

las instrucciones definidas a un lenguaje de programación. Si bien cada
lenguaje tiene una sintaxis diferente, todos manejan los mismos elementos
conceptuales, los cuales si son claros para el programador, le permitirán
emplear cualquier lenguaje con un mínimo tiempo de aprendizaje.
Para el desarrollo de nuestro curso, se emplea el lenguaje de programación
Visual C#, por lo cual, se presentará la sintaxis específica de este lenguaje al
tiempo que se presentan los conceptos generales.
Elementos básicos de programación
Los elementos básicos de programación se describen a continuación:
1. Variables
Las variables en programación son equivalentes a las variables que se
emplean en matemáticas, son palabras (a veces de una sola letra) que
representan valores que pueden variar a lo largo del programa. Las
variables en programación tienen dos características propias: nombre y
el tipo.
El nombre de la variable, conocido también como identificador, es el
que permite hacer referencia a la variable en cualquier parte del
programa. Cada lenguaje define algunos limitantes para la selección del
nombre de las variables, sin embargo, algunas normas generales de
buena programación son las siguientes:
● Una variable debe nombrarse con una o varias palabras que
indiquen el dato que contiene, por ejemplo: nombre, teléfono,
salario, temperatura, etc.
● El nombre de una variable no puede incluir espacios ni caracteres
especiales. Si el nombre se compone de varias palabras, pueden
enlazarse con subrayado o simplemente poner las palabras
seguidas una de otra, por ejemplo: salario_total,
temperaturaMedia, promedio_Semestral.

● El nombre de la variable debe empezar por una letra,
posteriormente puede incluir números. Si el nombre de una
variable inicia con un número, el computador puede entender
que se trata de un número y no de una variable. Por ejemplo,
semestre5, login123, etc.
El tipo de la variable, se refiere al tipo de dato que la variable podrá
almacenar. La mayoría de los lenguajes requieren que se establezca el
tipo de la variable y que no se cambie durante toda la ejecución del
programa. Adicionalmente, cada lenguaje tiene limitaciones propias
para cada tipo de datos (como el rango de datos válidos). Los tipos de
datos más generales son los siguientes:
● Entero: indica que las variables guardarán números negativos,
positivos o cero SIN parte decimal. En C# existen varios tipos
enteros: sbyte, short, int, long; la diferencia entre un tipo y otro es
el tamaño disponible para almacenar datos. El tipo de dato entero
más común es el int, que tiene un tamaño de 4 bytes y permite
almacenar números entre -2.147’483.648 y 2.147’483.647
● Reales o decimales: indica que las variables guardarán números
negativos, positivos o cero incluyendo parte decimal. En C#
existen dos tipo de datos reales: float y double. Al igual que con
los enteros, la diferencia entre ellos se basa en el tamaño
disponible. El tipo más común en los reales es el float que tiene 7
dígitos de precisión.
● Booleano: es un tipo de dato especial que permite almacenar
valores de verdad (verdadero o falso). En C# se emplea el tipo
bool y los únicos valores que puede tomar son True o False.
● Caracteres: indica que la variable almacenará caracteres únicos,
que pueden ser letras (‘a’,’F’,’z’), números como símbolos y no
como cantidad (‘3’, ‘9’,’0’) o caracteres especiales, que
corresponden a esos caracteres que se disponen y que no son
letras ni números (‘)’, ‘#’, ‘]’). Cuando se emplea un número como
símbolo (carácter) no es posible hacer operaciones aritméticas
con él. En C#, este tipo se denomina char y sus valores, siempre
se presentan entre comillas simples.

● Cadenas: algunos lenguajes disponen de un tipo de dato

especial, denominado cadena, que corresponde a un conjunto de
caracteres, por ejemplo “perro”, “mi casa es bonita”, “Maria
Martinez”, “ el promedio es 3.45”. En C# este tipo de dato, se
denomina String y los datos que almacena siempre se
representan entre comillas dobles.
2. Constantes
Las constantes se refieren a datos que no cambiarán su valor durante
la ejecución del programa, no requieren nombre y solamente se
trabajan con el dato correspondiente (3, 6.7, “hola”).
3. Operador de asignación
La definición de una variable supone que en alguna parte del proceso
establecido, la variable debe tomar un valor o cambiar el que tiene, una
forma de realizar esta operación es asignándole dicho valor, para ello se
emplea un operador específico. El operador de asignación empleado
por cada lenguaje puede diferir pero el más común es el operador =.
A través del operador de asignación se asigna el valor a la derecha del
operador (que podría ser una variable o constante) a la variable que se
encuentra a la izquierda del operador.

Ejemplo:

total = 35.6 asigna el valor 35.6 a la variable total
nombre=“Miguel” asigna la cadena Miguel a la variable

nombre.
promedio = nota asigna a la variable promedio el valor

que tenga (en ese momento) la variable
nota.
3=x es una expresión no válida, porque no

se puede asignar un valor a otro valor.


4. Expresiones
Como se explicó en la unidad anterior, las expresiones son sentencias
que toman un valor particular; en programación se distinguen las
expresiones aritméticas, que dan como resultado un valor numérico y
las expresiones lógicas que dan como resultado un valor de verdad
(dentro de las expresiones lógicas se incluyen las relacionales).
5. Operaciones
El último elemento constituyente de un programa de computadora son
efectivamente las operaciones o instrucciones que se pueden emplear.
Operaciones de lectura: son las operaciones con las que se permite al
usuario hacer el ingreso de los datos para que el programa funcione.
Operaciones de escritura: son las operaciones que permiten presentar

información en pantalla.
Decisiones: son operaciones que permiten definir un conjunto de

instrucciones que se ejecutarán bajo una condición específica.
Repeticiones o ciclos: Permiten definir un conjunto de instrucciones que
se repetirán mientras se cumpla una condición establecida.
6. Método
Un método o procedimiento se puede entender como una porción de
programa que realiza una tarea específica. Un método puede llamarse o
invocarse en cualquier momento dentro de un programa, en ese
momento se ejecutan las instrucciones del método y una vez termine se
regresa a continuar la ejecución del programa.
Al realizar el llamado o invocación al método, es posible enviar datos
que este requiera para realizar su operación, de forma similar, al
terminar la ejecución del método, se puede retornar un dato al
programa principal para que continúe su labor.
NOTA: Aunque pueden existir variaciones, en general, los métodos

(procedimientos, rutinas o funciones) en todos los lenguajes de

programación tienen la posibilidad de retornar un solo dato.

Actividad 4: Pruebas
La última actividad del proceso de desarrollo de software es la de pruebas, en

esta parte se ejecuta el programa bajo condiciones controladas para verificar
su corrección, es decir, verificar que cumple los requerimientos definidos
previamente.
Contrario a lo que se puede pensar, las pruebas no están diseñadas para
probar que el programa funciona bien, por el contrario, las pruebas se diseñan
intentando que el programa falle. Si al ejecutar las pruebas, el programa no
falla, se puede asegurar que bajo esas condiciones, el programa funciona bien,
pero no se puede asegurar que el programa funcionará bien bajo todas las
circunstancias.
Cada prueba incluye:
● Una descripción de la característica o funcionalidad que se desea probar.

● Los datos y valores que se deben emplear como entrada al programa.
● Los datos de salida que se deberían obtener.
● Para aplicaciones más complejas, deben indicarse las condiciones del sistema al
momento de la prueba.
Cada prueba se ejecuta verificando si la salida obtenida es la esperada, si es
así, se indica que la prueba es aprobada, de no ser así, debe empezar un
proceso de revisión del programa para encontrar la causa del error y corregir,
una vez realizado este proceso se ejecutan nuevamente todas las pruebas
para verificar que se corrigió efectivamente el error y que no se insertó otro
error en el proceso.


III. Introducción al Lenguaje C#

Visual C# es un lenguaje gráfico orientado a eventos, lo que significa que las
acciones se ejecutan en respuesta a eventos.
Un programa desarrollado en un lenguaje visual, tendrá dos componentes: al
interfaz gráfica (conocida como GUI por sus siglas en inglés – Graphic User
Interface) y el código o instrucciones del programa.
Inicialmente se desarrollará la GUI, agregando esencialmente: labels

(etiquetas), cajas de texto (para leer o mostrar datos) y botones.


El código del programa aparece en otra ventana y tiene una estructura similar

a la siguiente: inicialmente se encuentra una sección de variar instrucciones
4
using, esta sección le indica al lenguaje cuáles librerías se van a emplear en el
programa; posteriormente aparece una definición del namespace que
corresponde a la aplicación (si observa este nombre es el mismo que usted dio
a su programa al crear el proyecto); luego continúa la definición de clase, que
corresponde a la estructura empleada por el lenguaje y en la cual por ahora no
ahondaremos.
Lo que sí es importante es que dentro de la clase se ubican diferentes
métodos que responden a los eventos de los elementos incorporados en la
GUI, en general serán de la misma forma: tienen el nombre del elemento
(button1, label1, etc.) y la acción a la que responden (click).
4
Una librería es un conjunto de módulos o programas que ya se encuentran escritos en el lenguaje de
programación y pueden ser empleados por los programadores cuando lo requieran.

Estructura General:
Como convención en nuestro curso la estructura general de los programas es
que hay un botón que inicia la ejecución del programa (botón de calcular,
ejecutar, etc.), dentro del método correspondiente se realizará un llamado al
método principal() y dentro de este se ubicaran las instrucciones necesarias:
NOTA: En programas complejos el método o módulo principal se encarga de
operaciones de lectura y escritura y delega las instrucciones de
procesamiento a otro(s) método(s).

Operaciones:
Lectura de variables de entrada desde una GUI.
Cuando se trabaja con cajas de texto, debe tenerse en cuenta que son eso:
cajas de texto y por tanto, lo que se ingresa o se muestra en ellas es texto (o
cadenas). Para trabajar con los datos que se han ingresado, deben
transformarse al tipo requerido, de la siguiente forma.
Suponiendo que la caja de texto que contiene el dato se llama Control:
Lectura de cadenas String variable = Control.Text;


Ej: S tring nombre = textBoxNombre.Text;

Lectura de enteros int variable = int.Parse(Control.Text);
Ej: int edad = int.Parse( textBoxEdad.Text );
Lectura de reales double variable = double.Parse(Control.Text);
Ej: double estatura = double.Parse( textBoxEstatura.Text
Lectura de caracteres char variable = char.Parse(Control.Text);
Ej: char seguir = char.Parse( textBoxEstadoCivil.Text );

5
NOTA: Recuerde que todas las variables que se utilicen, deben ser declaradas
previamente.
Escritura (salida) de variables de entrada desde una GUI.
Para escribir o mostrar datos en la pantalla, generalmente usaremos cajas de
texto deshabilitadas (Enabled=false), para evitar que el usuario ingrese datos
en ellas.
Suponiendo que la caja de texto que va a contener el dato se llama Control:
Mostrar una cadena fija o constante Control.Text = “Constante de cadena”;

Ej: t extBoxSaludo.Text = “Hello World”;
Mostrar una variable de tipo cadena Control.Text = variable;
Ej: t extBoxNombre.Text = nombre;
Mostrar una variable de tipo diferente Control.Text = variable.ToString( ) ;
a cadena (debe transformarse a texto) Ej: t extBoxNota.Text = nota.ToString( ) ;

Algunas operaciones básicas con la GUI.
Estas son dos operaciones de uso común con las interfaces gráficas, la primera
permite cerrar la ventana o pantalla que se está ejecutando y la segunda
permite limpiar los datos contenidos en una caja de texto.
Cerrar GUI Close();
Limpiar componentes gráficos Cajas de texto Control.Clear();

Ej: t extBoxNombre.Clear( ) ;
5
La declaración de una variable implica darle un nombre e indicar el tipo de dato que va a almacenar.



IV. Programación Estructurada

En programación estructurada se emplean tres tipos de estructuras: las de
secuencia, que implica escribir una instrucción después de otra; las de decisión
que permiten representar las situaciones donde hay que decidir por un
camino u otro y las de repetición que permiten ejecutar un conjunto de
instrucciones varias veces.
Estructuras de decisión
Una estructura de decisión se emplea cuando en el desarrollo de un programa

debe tomarse una decisión que implica realizar una(s) instrucción(es) cuando
la condición sea verdadera y otra(s) cuando la condición sea falsa.
Diagrama de flujo
En el diagrama de flujo, se representa la decisión con un rombo, de forma que

por un lado se presentan las instrucciones que se realizarán cuando la
expresión sea Falsa y por otro se presentan las instrucciones que se realizará
cuando la expresión sea Verdadera.
OBSERVACIONES: Es importante considerar los siguientes aspectos:
● El contenido del rombo debe ser una expresión lógica, que tenga como
resultado Falso o Verdadero.
● Del rombo, salen solamente dos caminos; cada uno de los cuales debe
estar marcado con SI o NO.
● En cada lado del rombo se pueden incluir todo tipo de instrucciones
(lectura, proceso, salida, incluso otras decisiones).
● En algún punto y en todo caso, antes de terminar el programa, deben

unirse nuevamente los dos caminos que se originaron en la decisión.
Sintaxis en C#
En C#, una estructura de decisión se define con la palabra clave if. La
estructura general de la instrucción es la siguiente:
if ( condición )
{
// instrucciones que se ejecutan si la condición es verdadera.
}
else
{
// instrucciones que se ejecutan si la condición es falsa.
}

Algunas recomendaciones para tener presentes:
● La condición debe estar escrita entre paréntesis y debe corresponder a
una expresión lógica (cuyo resultado sea Verdadero o Falso).
● Una vez se abre una llave, todas las instrucciones que se escriban se
consideran dentro del mismo bloque (verdadero o falso) hasta que se
cierre la llave respectiva.
● La palabra clave else y el bloque respectivo, no son obligatorios. Ya que
una decisión puede no tener instrucciones para realizar cuando la
condición sea Falsa.
● La palabra clave else (si se incluye) debe escribirse inmediatamente
después de la llave que cierra el bloque de instrucciones verdadero.
A continuación se presentan algunos ejemplos de utilización de la estructura
de decisión.
Ejemplo 1: Calcular la longitud de una circunferencia si el radio es positivo.



if ( radio > 0 )
{
longitud = 2 * 3.1416 * radio ;
}

Ejemplo 2: Dada la edad de una persona, imprimir un mensaje sólo si ella
cumple con la mayoría de edad.

if ( edad >= 18 ){
salida.text=”La persona tiene la mayoría de edad”;
}

Ejemplo 3: Calcular la longitud de una circunferencia si el radio es positivo y,
en caso contrario, se proporciona un mensaje de error.

if ( radio > 0 ){

longitud = 2 * 3.1416 * radio;
}
else // si radio <= 0
{
alida.text =“Radio incorrecto”
s ;


}
Ejemplo 4: Dada la edad de una persona, imprimir un mensaje indicando si es

mayor de edad o no.
if ( edad >= 18 )

{
salida.text=“La persona tiene la mayoría de edad” ;
}
else
{
salida.text= “La persona no tiene la mayoría de edad” ;
}
Estructura de Decisión Múltiple
C# como otros lenguajes ha definido lo que se denomina una estructura de
decisión múltiple, que permite evaluar los diferentes valores que puede tomar
una variable (o expresión) y de acuerdo a ello, realizar diferentes operaciones.
NOTA: Toda operación que se pueda realizar empleando estructuras de
decisión múltiple, igualmente puede presentarse con estructuras de decisión

básicas, sin embargo está la estructura de decisión múltiple es más eficiente
en escritura y ejecución.
Diagrama de flujo
Sintaxis en C#
En C#, la instrucción de decisión múltiple se presenta así:
switch( variable o expresión a evaluar )

{
case valor1:
// Bloque de instrucciones que se ejecuta si la expresión
// toma el valor valor1
break ;
case valor2:
// toma el valor valor2
break;

// . . . . . .
case valorN:
// toma el valor valorN
break;
default:
// NO toma ninguno de los valores arriba indicados
/ Llave de fin de la estructura de decisión múltiple
} /

Algunas recomendaciones para tener presentes:
● La expresión o variable que se incluye en el paréntesis, debe ser del
mismo tipo de cada uno de los valores que se incluyen en los
diferentes casos.
● El uso de la palabra clave break, al final de cada caso es muy
apropiado. Esta sentencia, rompe el proceso de ejecución y lo traslada
después de la estructura, es decir, cuando se encuentre la palabra
break, el programa continúa ejecutando las instrucciones que hay
después de la llave que cierra la sentencia switch.
● Los casos no requieren ningún orden específico.
● Solamente se puede emplear esta estructura en casos de igualdad, es
decir cuando la variable o expresión en el paréntesis sea igual al
valor1, o igual al valor2, etc. Para casos de rangos (mayor que, menor
que, etc.) no se podría emplear esta estructura.
● La sentencia default no es obligatoria, aunque es bastante útil para
saber cuándo se ha obtenido un valor que no se consideró en la lista
de casos definidos.
● El último caso incluido (sea default u otro), no requiere la sentencia
break, ya que en ese punto termina la estructura de decisión.
Observe que las únicas llaves incluidas son las que abren y cierran la
sentencia switch. En cada uno de los casos no se requiere el uso de llaves.
Ejemplo 1: si mes es el cardinal de un mes del año (1 para enero, 2 para


febrero, etc.), indique el número de días que tiene dicho mes.
switch ( mes ) {
case 1: salida.Text= “31” ;
break;
case 2: salida.Text= “28 días, 29 días si el año es bisiesto”;
break;
break;
break;
break;
break;
break;
break;
break;
break;
break;
break;
default:
salida.Text= “Mes incorrecto” ;
}



Estructuras de Repetición
Otra de las estructuras usadas habitualmente en programación corresponde a

las estructuras de repetición o ciclos, son aquellas estructuras que permiten
ejecutar una serie de instrucciones en varias ocasiones. En todos los lenguajes
de programación existen instrucciones precisas que permiten construir este
tipo de estructuras.
¿Cuándo hay un proceso de repetición?
La respuesta a esta pregunta es bastante fácil, cuando se requiere desarrollar
el mismo conjunto de instrucciones (1, 2 o más instrucciones) más de una vez.
Por Ejemplo:
● Se requiere calcular la nota definitiva de 20 estudiantes de una
asignatura.
● Se requiere calcular el valor del paquete turístico para todos los
clientes que compren en un día.
● Se requiere que el programa permita al jugador realizar tantos
intentos como desee para pasar de un nivel a otro.
● Si el usuario digita 3 veces la clave incorrecta, debe bloquearse la
cuenta.
La estructura
Una estructura de repetición tiene tres elementos constituyentes:
1- Condición: la repetición siempre es controlada por una condición; en
algunos casos, se repite cuando la condición sea verdadera y se termina
el proceso cuando la condición es falsa; en otros casos, se repite cuando
la condición sea falsa y se termina el proceso cuando la condición es
Verdadera. Pero independiente de esto, se debe entender que la
condición será la que controle el ciclo de repetición.
2- Instrucciones: Se entiende aquí el conjunto de instrucciones que se
desea repetir, estas pueden ser de cualquier tipo: lecturas, escrituras,
procesos de cálculo, llamado a métodos, estructuras de decisión e
incluso, otras estructuras de repetición.


3- Cambio de la condición: Para asegurar que las repeticiones terminen en

algún momento y no se convierta en un ciclo infinito, debe asegurarse
que en alguna instrucción, dentro del ciclo, se haga el cambio de una o
varias variables que se encuentran involucradas en la condición que
controla el ciclo; este cambio en la variable, puede deberse a que se lee
nuevamente o simplemente por la asignación de un nuevo valor.
Diagrama de flujo
Los ciclos en el flujograma se identifican fácilmente porque incluyen una
condición y una flecha dirigida hacia arriba, que implica el reprocesamiento de
algunas operaciones. Como se dijo anteriormente, la flecha hacia arriba puede
corresponder al camino negativo de la decisión o por el camino positivo,
dependiendo de la forma de la estructura.
Ciclo para / mientras Ciclo haga mientras

Ejemplo: Se requiere un programa que permita leer 100 números y obtener la

suma total de ellos.



Para este caso los Datos de Entrada son los 100 números y el Dato de Salida es
la suma de ellos.
NOTA: hay varias formas de realizar este algoritmo, una que es dispendiosa
pero válida, es leer 100 variables diferentes y sumarlas; pero como no se
quiere hacer un trabajo tan arduo, lo que se puede hacer es leer un número,
sumarlo sobre una variable y repetir las operaciones 100 veces.
Para lograr las 100 repeticiones, emplearemos algo que todos usamos a diario:
contar, una variable nos ayudará a contar desde 1 hasta 100, cuanto termine,
sabremos que se han completado 100 veces.

Una solución con ciclo haga mientras (do while)


Una solución con ciclo mientras o para (while / for)


Ciclo haga mientas (do while) Ciclo mientras (while)/ para (for)
comparando el ciclo haga mientras vs mientras/para
Sintaxis en C#
En el lenguaje de programación Visual C# se han definido tres formas
diferentes para escribir estructuras de repetición, aunque las tres formas son
válidas y útiles para cualquier caso de repetición, hay unas formas que son
más pertinentes ante ciertas situaciones que otras. La estructura de repetición
establecida en el flujograma puede “traducirse” con cualquiera de las formas
del lenguaje de programación.


Forma 1: Ciclo FOR

La sintaxis para un ciclo for, es la siguiente:
or(instrucciones iniciales; condición; instrucciones finales) {

f
// instrucciones a repetir
}
La estructura incluye tres bloques dentro del paréntesis, cada uno de los
cuales se separa con punto y coma:
● Instrucciones iniciales: son las primeras instrucciones que se

ejecutarán en el ciclo, generalmente se emplean para dar valor inicial a
las variables. Pueden incluir varias instrucciones, en cuyo caso se
separan con coma (,).
● Condición: Debe ser una expresión lógica, cuya solución sea
Verdadero o Falso. En este caso, el ciclo se repetirá cuando la
condición sea VERDADERA, en el momento que la condición sea Falsa,
el ciclo terminará y continuará ejecutando las instrucciones que siguen
después del bloque de repetición.
● Instrucciones finales: estas instrucciones se ejecutarán al final del
ciclo (después de las instrucciones a repetir), nuevamente pueden ser
varias instrucciones separadas por coma. Aunque se pueden incluir
diferente tipo de instrucciones, generalmente esta sección se utiliza
para variar el valor de las variables que se incluyen en la condición.
● Instrucciones a repetir: se refiere a las instrucciones que conforman
efectivamente el cuerpo del ciclo, es decir, las instrucciones que se
requiere realizar múltiples veces y que dieron origen a la estructura de
repetición. Como se mencionó, en este bloque se pueden incluir
cualquier tipo de instrucciones: lectura de datos, cálculo y asignación
de valores, escritura de datos, llamado e invocación de métodos,
estructuras de decisión u otras estructuras de repetición.


OBSERVAR QUE: Cuando se emplee una estructura for debe tenerse cuidado
con los siguientes aspectos:
● El bloque de instrucciones a repetir, tal como todos los bloques en
Visual C#, debe estar entre llaves {…}
● En el encabezado de la estructura, se incluye entre paréntesis, tres
secciones, separadas por punto y coma. Las tres secciones deben
mantenerse, aunque no tenga instrucciones.
Utilización: La estructura for es empleada comúnmente para los casos en los
que se conoce previamente el número de repeticiones que se van a ejecutar.
Ejemplo 1: Se requiere un programa que muestre los números de 1 a 5
Prueba escritorio:
Código fuente en C#
for (int i = 1; i <= 5; i=i+1) {
tbnumero.Text = i.ToString();
}


En este caso la variable i, es una variable que permite controlar el ciclo, como
se puede observar en la primer parte del ciclo (instrucciones iniciales) se
declara la variable i que se inicia en 1; en la parte final (instrucciones finales) se
incrementa el valor de la variable i en 1, es decir, si tiene como valor 1 cambia
a 2, si tiene como valor 2 pasa a 3 y así sucesivamente. La condición es que la
variable sea menor o igual a 5, recuerde que en este tipo de ciclos, se repiten
las instrucciones mientras la condición sea verdadera, en este caso, dado que
la variable se inició en 1 y va incrementando de uno en uno, el ciclo se repetirá
cuando i tenga los valores de 1, 2, 3, 4, 5 en el momento que la variable tome
el valor 6, la condición se torna falsa y por tanto, el ciclo termina.
Ejemplo 2: Se requiere un programa que lea 10 números enteros y al final
indique cuántos fueron positivos (mayores que cero), cuantos negativos
(menores que cero) y cuántos cero (iguales a cero).



Prueba escritorio
positivos negativos ceros numero num
0 0 0 0 0
1 1 1 5 1
2 2 2 -3 2
3 3 3 0 3
4 10 4
25 5
-1 6
2 7
-1 8
0 9
0 10
El código fuente en C# es el siguiente:
int positivos=0;
int negativos = 0;
int ceros = 0;
int numero = 0;
for (int num=0; num<10; num = num +1) {
numero=int.Parse(Interaction.InputBox("digite el número: "));
if (numero > 0 ) {
positivos = positivos +1;
}//fin if
else {
if (numero < 0) {
negativos = negativos +1;
}//fin if

else { //si no es positivo ni negativo, debe ser cero.

ceros = ceros +1;
}//fin else
}//fin else
}//fin for
tbnumerosPositivos.Text = positivos.ToString();
tbnumerosNegativos.Text = negativos.ToString();
tbnumerosCeros.Text = ceros.ToString();
La instrucción I nteraction.InputBox(string,string, string, int,int) permite que se lean datos a través de una ventana
emergente, pero requiere que se incluya la instrucción u sing Microsoft.VisualBasic; en la parte inicial del
programa y se incluya VisualBasic en References de la aplicación.
Observe que: en este caso, se tienen 4 variables que, bajo ciertas
circunstancias, van aumentando de 1 en 1, a este tipo de variables se les
conoce como contadores, porque su valor va incrementando cada vez en un
valor constante, en este caso 1. La variable num, incrementa en cada
ejecución del ciclo y por ello, se dice que va contando la cantidad de veces que
se ha repetido el ciclo; de forma análoga, la variable positivos cuenta la
cantidad de números positivos (solamente incrementa cuando el número es
mayor a 0), la variable negativos cuenta la cantidad de números negativos
(solamente incrementa cuando el número es menor a 0) y la variable ceros
cuenta la cantidad de ceros que se digite (solamente incrementa cuando el
número no es mayor a cero y no es menor a cero).
NOTA: En este caso, el contador de los números (num) se inicia en 0, por esto
la condición es <10 y no <=10; de forma que el ciclo se repetirá cuando num
tenga valores de 0,1,2,3,4,5,6,7,8 y 9 (10 veces en total). El ciclo termina
cuando la variable num toma el valor de 10 ya que la condición num < 10 da
como resultado falso.


Ejemplo 3: Se requiere un programa que lea las edades de 150 estudiantes de

primer semestre de una carrera y calcule la edad promedio de dichos
estudiantes.

…
int edad;
double edadtotal = 0;
double edadpromedio;
for(int estudiante =0; estudiante < 150; estudiante = estudiante + 1){
edad= int.Parse(Interaction.InputBox("digite la edad: "));
edadtotal = edadtotal + edad;
}//Fin del for
promedio = edadtotal / 150.0;
…

Aquí, se requiere hacer una sumatoria de todas las edades para luego
dividirlas sobre el total de personas (150) y de esa forma obtener el promedio
de las edades. Este programa ha incorporado un contador (estudiante) que
ayuda a controlar la cantidad de veces que se va a repetir, en este caso,


cuántas edades sea va a leer.
Se utiliza, además, otra variable edadtotal, que va sumando los valores de las
edades leídas, esta variable inicia en 0, si la primera edad leída es 20, edadtotal
tomará el valor de 20, si la segunda edad leída es 15, edadtotal tomará valor
de 35 (20+15), si la tercera edad leída es 18, edadtotal tomará el valor de 53 (35
+ 18) y así sucesivamente; las variables que tienen esta función se conocen
como acumuladores, ya que su propósito es acumular o hacer la sumatoria de
un dato particular y su valor se incrementa en una cantidad variable (en este
caso, la edad).
Forma 2: Ciclo WHILE

La sintaxis del ciclo while es la siguiente:

while (condición) {
//Instrucciones a repetir
}
Al igual que en la estructura anterior, la estructura while se repite cuando
(mientras) la condición es verdadera, en el momento que el valor de la
condición cambia a falso, se termina el ciclo y el programa continúa
ejecutando las instrucciones que se encuentren después de la estructura.
En un ciclo while, no se define un espacio explícito para las instrucciones que
inician las variables involucradas en el ciclo (iniciación), ni para hacer el cambio
de valor de dichas variables (finalización), no obstante deben incluirse este tipo
de instrucciones, para asegurar el correcto desarrollo del ciclo.
Utilización: Este tipo de ciclos resulta muy útil para los casos en que se conoce

el número de repeticiones que se va a realizar, así como en los casos en los
que no se conoce con antelación dicho número.
OBSERVACIÓN: Por regla general, los ciclos de repetición se pueden
desarrollar con cualquier de las estructuras del lenguaje. A continuación se
presentan los mismos ejemplos que se revisaron previamente, pero


empleando la estructura while.
Prueba escritorio:
int i=1;
while (i<= 5) {
tbnumero.Text = i.toString();
i = i + 1;
}
La operación en este caso es exactamente igual a la obtenida con la estructura

for, observe que la iniciación de la variable de control (i) se realiza antes de
empezar el ciclo y el incremento (variación de valor) se hace dentro del ciclo.


indique cuántos fueron positivos, cuantos negativos y cuántos cero.
int positivos=0;
int negativos = 0;
int ceros = 0;
int numero = 0;
int num=0;
while (num<10) {
numero=int.Parse(Interaction.InputBox("digite el número:");
if (numero >0 ) {
}//Fin del if
else{
if (numero < 0) {
}//Fin del if
else{

ceros = ceros +1;

}// Fin del else
}//Fin del else
num = num + 1;
}//Fin del while
En este caso, debe prestarse especial atención a que el incremento de la
variable de control (num) se realice por fuera de cualquier decisión, para
asegurar que sin importar el resultado de las decisiones se incremente la
variable.


estudiantes.

…
int edad;
double edadtotal = 0;
int estudiante = 0;

while (estudiante < 150){

estudiante = estudiante + 1;
}//Fin del while
…

Sin embargo, hay otro tipo de aplicaciones que resultan más fáciles de
desarrollar con una estructura while que con una estructura for. Por ejemplo,
aquellas donde no se sabe de antemano cuántas veces se van a repetir las
instrucciones, sino que depende de alguna variable leída o calculada durante
el ciclo.
Ejemplo 4: Se quieren leer y sumar tantos números como el usuario desee.
Prueba de escritorio:
numero numeroTotal otro
0 0 S
10 10 S
25 35 S
-5 30 N


int numero =0, numerototal=0;

char otro = ‘S’;
while (otro ==’S’) {
numero= int.Parse(Interaction.InputBox("digite el número:"));
numerototal = numerototal + numero;
otro=char.Parse(Interaction.InputBox("¿Desea otro número S/N:?"));
}//Fin del while
...
En este caso no se puede saber (y no es necesario saberlo) previamente
cuántas veces se va a repetir el ciclo, se ejecutan las acciones y al final se
pregunta al usuario si quiere ingresar otro número, se repetirá mientras el
usuario digite S, si digita cualquier otro carácter, el ciclo terminará.
IMPORTANTE: Como se puede observar, esta clase de ciclo inicia preguntando

sobre la validez de la condición, por ello, es importante que la condición sea
verdadera al menos una vez, de otra forma nunca se realizaría el ciclo. En el
caso anterior, la variable otro se inicia con el valor ‘S’ antes de iniciar el ciclo, si
no se hiciera este paso, el ciclo no se realizaría.
Forma 3: Ciclo DO - WHILE

La sintaxis del ciclo do-while es la siguiente:

do {
//Instrucciones a repetir
}while (condición);
Este ciclo maneja dos palabras clave: do que marca el inicio del ciclo y va
seguido de la llave de apertura del bloque y while, escrito a continuación de la
llave que cierra el bloque, va seguido de la condición y debe cerrarse con
punto y coma.
Al igual que las otras estructuras presentadas, este ciclo se repite cuando


(mientras) la condición sea verdadera. Sin embargo, tiene una diferencia
fundamental con las otras estructuras y es que, en este caso, el ciclo siempre
se ejecuta al menos una vez. Debido a que la condición se escribe al final, las
instrucciones del ciclo siempre se ejecutarán al menos por una vez, después
de lo cual se revisa la condición y entonces podría terminar el ciclo. En los
ciclos for y while, la condición se encuentra al inicio de la estructura, por lo cual
es posible que al empezar el ciclo la condición sea falsa y por lo tanto no se
ejecuten ni siquiera una vez.
Utilización: Al igual que las estructuras while, el do-while se puede emplear
cuando se tienen ciclos en los que se conoce o no con antelación el número de
veces que se va a repetir el ciclo. Adicionalmente, por su condición particular
esta clase de estructura es muy útil cuando se quiere ejecutar las instrucciones
al menos una vez, por ejemplo para la validación de datos de lectura.
Retomamos los ejemplos anteriores para presentar cómo se pueden

desarrollar empleando esta estructura:


i tbnumero.tex
1 1
2 2
3 3
4 4
5 5
Código fuente en C#:

int i=1;
do {
tbnumero.Text = i.toString();
i = i +1;
}while (i<=5);

Para este caso, nuevamente tenga en cuenta que la iniciación de la variable de

control (i) se realiza antes de empezar el ciclo y el incremento (variación de
valor) se hace dentro del ciclo.


indique cuántos fueron positivos, cuantos negativos y cuántos cero.


int positivos=0;
int negativos = 0;
int ceros = 0;
int numero = 0;
int num=0;
do
{
numero= int.Parse(Interaction.InputBox("digite el número: "));
if (numero >0 )
{
}//Fin del if
else
{
if (numero < 0)
{
}//Fin del if
else
{
ceros = ceros +1;
}//Fin else
}//Fin else
num = num + 1;
}while (num<10);//Fin del do while


estudiantes.



int edad;
double edadtotal;
int estudiante = 0;
do{
estudiante = estudiante + 1;
}while (estudiante < 150);//Fin del do while
…



Ejemplo 4: Se quieren leer y sumar tantos números como el usuario desee.

numero numeroTota otro
l
0 0
10 10 S
15 25 S
0 25 S
-1 24 N


int numero =0, numerototal=0;
char otro;
do{
numero= int.Parse(Interaction.InputBox("digite el número: "));
numerototal = numerototal + numero;
otro = char.Parse(Interaction.InputBox("¿Desea otro número: ?"));
}while (otro ==’S’);//Fin del do while



Para este caso, el uso de la estructura do-while tiene una ventaja, no es
necesario asignar valor a la variable de control (otro) antes de iniciar el ciclo, ya
que la lectura de la variable se realiza antes de terminar el ciclo y por tanto, en
el momento que se evalúa la condición, la variable ya tiene un valor válido.
Un caso en el que es muy útil este tipo de estructuras es cuando se requiere
validar un dato de entrada, para verificar que el valor ingresado se encuentre
dentro del rango de datos aceptados para el programa; la idea es que si el
usuario no ingresa el valor apropiado, se pida nuevamente el dato hasta tanto
el valor ingresado se encuentre en el rango válido. Por ejemplo:
Ejemplo 5: El número de estudiantes debe ser mayor a 0

numest
-5
0
2

int numest;
do {
numest= int.Parse(Interaction.InputBox("digite el número: ")
}while (numest <= 0 );//Fin del do while



Observe que: Debe recordarse que el ciclo se va a repetir cuando la condición

establecida sea verdadera, entonces para estos conviene preguntarse ¿Si se
requiere que el número sea mayor que 0, cuándo deberá repetirse el ciclo? En
este caso, el ciclo deberá repetirse, es decir, volver a preguntar el número de
estudiantes cuando no sea mayor a 0, es decir, cuando el número sea menor o
igual a 0.

Ejemplo 6: La nota ingresada debe estar entre 0.0 y 5.0

Nuevamente, debe hacerse la pregunta, ¿en qué caso debe repetir la lectura?
Respuesta: cuando la nota ingresada no esté entre 0.0 y 5.0, es decir, sea
menor a 0.0 o mayor a 5.0

nota
-2
10
-3
3,5

double nota;
do{
nota = double.Parse(Interaction.InputBox("digite la nota: "));
}while ((nota < 0.0) || (nota > 5.0));//Fin del do while.



Ejemplo 7: El estado civil puede ser S, C ó D.
Ante la pregunta sobre cuándo repetir el ciclo, sería cuando el estado civil sea
diferente de S, diferente de C y diferente de D.


estado
m
a
casado
C

char estado;
do {
estado = char.Parse(Interaction.InputBox("¿estado civil: ?"));
}while((estado != ´S´) && (estado !=´C´) && (estado !=´D´));
//Fin del do wile.



Ejemplo 8: El programa puede ser Ingeniería o Economía.
En este caso, el ciclo debe repetirse cuando el programa ingresado sea
diferente a Ingeniería y diferente a Economía.

programa
Industrial
Ing
Ec
Ingeniería
String programa;
do {
programa = Interaction.InputBox("¿estado civil: ?");
}while(((!programa.equals(“Ingeniería”))&&(!programa.equals(“Economía”)));



V. Métodos
Como se mencionó previamente, los métodos se pueden considerar
mini-programas, que tienen una función o propósito específico, en este
sentido, los métodos tienen unos aspectos que los identifican:
• Un método tiene un único propósito u objetivo, un método realiza una
única tarea de forma completa.
• Un método puede ser llamado o invocado desde múltiples puntos del
programa. Al llamar un método lo que ocurre es que se ejecutan las
operaciones que éste incluye y una vez termine se continúa la ejecución
del programa en el punto donde había quedado.
• No es común que se tengan operaciones de lectura o escritura en un
método, ya que el método, en general se emplea para realizar ciertas
operaciones precisas. En caso de ser requerido, pueden hacerse
operaciones de lectura y/o escritura en un método, pero no es común.
Utilización: Los métodos son bastante útiles cuando se dispone de una
operación que es común y que puede ser empleada en múltiples ocasiones,
por ejemplo, las funciones que se pueden ejecutar con la calculadora (log, sen,
cos, tan,…), es más fácil tener el método y llamarlo, que tener que escribir las
instrucciones cada vez que se quiere ejecutar la operación.
Elementos
Un método tiene los siguientes elementos:
• Parámetros de entrada: corresponde a los datos que se requieren que

sean enviados al método para realizar su operación, son equivalentes a
los datos de entrada a un programa; solamente que en el método no se
leen sino que se reciben. Por ejemplo si se considera como método
SUMAR, se requiere que sean enviados dos números para sumar, estos
serían los parámetros de entrada. Algunos métodos podrían operar sin
datos de entrada.
• Dato de Salida: es el dato (variable) que se obtendrá como resultado
después de ejecutar las instrucciones del método.
• Instrucciones: Corresponde a todas las instrucciones que se ejecutarán

al interior del método. Un método puede incluir cualquier clase de
instrucciones: cálculos, decisiones, ciclos, llamado a otro método, etc;
aunque como ya se especificó, no es común que existan operaciones de
lectura y escritura en un método.
Diseño (flujograma)
En el flujograma el llamado a un método se representa como una caja con
doble línea vertical a cada lado, dentro de la cual se escribe el nombre del
método, con los datos que se le envían y el dato que se recibe como respuesta.

El método tiene su propio flujograma, que presenta el proceso que se lleva a
cabo dentro del método, la única diferencia con el flujograma principal es que
el punto de entrada al método se nombra como ENTRADA y no inicio, el punto
de salida del programa se nombra como SALIDA y no fin.
En la entrada se pueden incluir los datos que se deben pasar al método como
parámetros de entrada y en la salida se puede indicar el nombre de la variable
que se devuelve como resultado del método.
Ejemplo:


Sintaxis en C#
En Java los métodos tienen dos partes esenciales, el encabezado (también
llamado cabezote, signatura o firma del método) y el cuerpo del método.
• La signatura del método incluye cuatro partes: (1) el modificador de
acceso del método (visibilidad) , (2) el tipo de retorno, que corresponde
al tipo de dato que el método va a devolver, si no devuelve ningún dato,
se escribirá void, (3) el nombre de método, que sigue los mismos
principios de cualquier identificado: debe iniciar con una letra, no tener
espacios ni caracteres especiales, (4) tipo y nombre de los parámetros,
para cada dato de entrada debe incluirse el tipo y un nombre de
variable que será empleado en las instrucciones al interior del método.
6
La signatura entonces, tendría la siguiente estructura :
<visibilidad><tipo de retorno><nombre del método>(<tipo y nombre de los

parámetros>)
• Cuerpo del método: corresponde a las instrucciones que se incluyen en

el método para cumplir su función. Si el método retorna algún dato
como resultado, deberá incluir la instrucción return, seguida de un valor
o variable del tipo de dato definido para el retorno. Debe tenerse en
cuenta que la instrucción return finaliza la ejecución del método y
regresa el control al programa principal.

Ejemplo 1: Realizar un método que compara dos números enteros e indique el
de mayor valor.

En este caso, el método requiere como parámetros de entrada, dos números
enteros; el dato a regresar (o retornar) es, a su vez, un número entero. La
signatura del método quedaría de la siguiente forma:
6
Los signos de < > se emplean para indicar que es en este sitio se incluye un valor variable.

public int calcular_mayor(int numero1, int numero2)
después de la palabra clave public, se incluye int, haciendo referencia al tipo
de dato que el método va a retornar, después el nombre del método:
calcular_mayor y finalmente entre paréntesis y separados por coma, los
parámetros de entrada (dos números enteros).
El método completo se podría ver así:
public int calcular_mayor(int numero1, int numero2) {

int mayor;
if (numero1 > numero2) {
mayor = numero1;
}//Fin del if
else {
mayor = numero2;
} //Fin del else
return mayor;
}//Fin del subproceso calcular_mayor

Observe que: las variables numero1 y numero2 no deben declararse


nuevamente dentro del método, ya que quedan declaradas en la definición de

parámetros y por tanto pueden emplearse al interior del método. Sin
embargo, la variable mayor sí debe declararse dentro del método y al final
será retornada (en este caso la variable a retornar –mayor- debe ser del mismo
tipo que se ha definido en el encabezado del método.

Ejemplo 2: Se requiere un método que lea 10 números reales y retorne su
promedio.

En este caso, se podrían ingresar los 10 números como parámetro pero es
bastante engorroso, es más fácil leerlos dentro del método y hacer el cálculo
requerido.


public double promedio ( ) {

double numero;
double promedio=0;
for (int i = 0; i < 10; i=i+1 ){
numero=double.Parse(Interaction.InputBox("digite la nota:"));
promedio = promedio + numero;
}//Fin del for
promedio = promedio / 10;
return promedio;
}//Fin del subproceso promedio.

Observe que: En este método no se requieren parámetros de entrada, sin
embargo deben incluirse los paréntesis respectivos.
Ejemplo 3: Se requiere un método que reciba dos números enteros y muestre

el mayor. En caso de que los dos números sean iguales debe mostrar que son
iguales.

Este es un caso, en el que se imprimen los datos de salida dentro del método y

por lo tanto, no es necesario retornar ningún valor.


public void calcular_mayor(int numero1, int numero2) {

int mayor;
if(numero1 > numero2) {
mayor.Text = numero1.toString();
}//Fin del if
else{
if (numero2>numero1){
mayor.Text = numero2.toString();
}//Fin del if
else{
mayor.Text = “Los dos números son iguales”;
}//Fin del else
}//Fin del else

Observe que: En este caso, no se debe retornar ningún valor, por lo
tanto el método se declara como void en el encabezado y no hay
sentencia de retorno (return).


Otra solución:
public string calcularMayorV2(int numero1, int numero2) {

string mayor;
if (numero1 > numero2) {
mayor = numero1.toString();
}//Fin del if
else{
if (numero2>numero1) {
mayor= numero2.toString();
}//Fin del if
else{
mayor = “son iguales”;
}//Fin del else
}//Fin del else
return mayor


Observe que: En este caso, si se debe retornar un valor, por lo tanto el
método se declara como string en el encabezado y si hay sentencia de
retorno (return).

Invocación o llamado al método
Una vez definido el método se puede llamar o invocar desde otra parte del
programa; para ello, se utiliza el nombre del método, incluyendo valores o
variables del mismo tipo de los parámetros de entrada definidos en el método;
adicionalmente, si el método retorna algún valor, debe asignarse el resultado a
una variable del tipo definido.
Ejemplo: para el método que tiene el siguiente encabezado:
public int calcular_mayor(int numero1, int numero2)
son válidas las siguientes invocaciones:
int resultado = calcular_mayor(3,7);
int primero=4;
int segundo = 59;
int x = calcular_mayor(primero, segundo);
Para el método que tiene el siguiente encabezado:
public double promedio ( )
double prom = promedio();
public void calcular_mayor(int numero1, int numero2)


calcular_mayor(34,8);
int n1=56, n2 = 58;
calcular_mayor(n1,n2);
Observe que: en este caso, debido a que el método no retorna un valor, no es

necesario asignar el llamado del método a una variable.
public String calcular_mayorV2(int numero1, int numero2) { … }
String mayor = calcular_mayorV2(34,34);

int n1=56, n2 = 58;
mayor = calcular_mayor(n1,n2);
Observe que: en este último caso, debido a que el método si retorna un valor,

es necesario asignar el llamado del método a una variable.


VI. Estructuras Estáticas

Hasta ahora se ha trabajado con variables numéricas y lógicas para
almacenar datos, sin embargo, estas solo permiten almacenar un solo dato,
el último almacenado. Si necesito almacenar varios datos, solo es posible
utilizando muchas variables, o usando una variable como acumuladora, lo
cual resulta ineficiente. Es por este motivo que trabajaremos con estructuras
de datos estáticas para el manejo de volúmenes de información.
Aquí se entiende estructura de datos como un agrupamiento de elementos.
La forma más simple es agrupar elementos de igual tipo de dato y asociar un
número de orden, o índice de posición, a cada elemento: esto es lo que
ocurre en las estructuras de datos denominadas a rreglos.
a. Arreglos
Un arreglo es una colección finita y homogénea de elementos.
● Finita: todo arreglo tiene un límite; es decir, debe determinarse
cuál será el número máximo de elementos que podrán
almacenarse en el arreglo.
● Homogénea: todos los elementos de un arreglo son del mismo
tipo de dato (todos enteros, todos reales, etc.), pero nunca una
combinación de distintos tipos de dato.
● Todos sus elementos están referenciados bajo un mismo
nombre.
● Cada elemento del arreglo se puede acceder mediante índices
(con los valores 0, 1, 2, 3, … , n - 1, donde n es el número máximo
de elementos que puede contener el arreglo), los cuales se
encierran entre corchetes [ ] después del nombre del arreglo, por
ejemplo emails[7] se refiere al elemento (un email) con índice 7
del arreglo e mails.
Los arreglos representan, en un contexto de programación, a las

entidades matemáticas denominadas vectores y matrices.


i. Arreglos Unidimensionales (Vectores)
Podemos imaginar un vector como una secuencia contigua de

celdas (espacios en memoria), o casillas, en cada una de las cuales
se puede guardar un elemento de la colección.
Cada una de las casillas de un arreglo tiene asociado un número
que la identifica de manera única. A este número se le llama índice.
En lenguajes como C, C++, C# y java, la primera casilla del arreglo
tiene índice 0, la segunda tiene índice 1, la tercera índice 2, y así
sucesivamente. Es muy importante tener presente que si el arreglo
puede almacenar hasta N elementos, la última casilla tendrá índice
(N - 1), donde N también se conoce como la dimensión o tamaño del
vector; es decir, el número máximo de elementos que puede
almacenar.
Es usual dibujar un vector como se ilustra en la siguiente figura:

Figura X. Representación gráfica de un vector

Para el ejemplo de la figura:
N = 10 (número de elementos del vector, o dimensión / tamaño); es

decir, el vector puede almacenar hasta 10 elementos.
El índice está en el rango de 0 a 9 como se puede observar.


Operaciones sobre arreglos unidimensionales
Declaración
En el pseudo-lenguaje, un arreglo se declara usando el siguiente
formato o plantilla:

<NOMBRE>[ ] : arreglo [<N>]

donde:
<NOMBRE> → Corresponde al nombre o identificador del arreglo
unidimensional
arreglo → indica que se va a trabajar con un arreglo; es decir, con
una variable que puede guardar uno o más valores(multivalor).
[<N>] → es la dimensión o tamaño del arreglo.

Ejemplo 1: declarar un arreglo

En el flujograma y según el pseudo-lenguaje:
En el ejemplo se crea un arreglo con nombre letras, de dimensión

15 y que puede almacenar datos de tipo c arácter.
En lenguajes como C# en la declaración de un arreglo
unidimensional o vector se tienen dos opciones.
Inicialización, primera opción:


<Tipo> [ ]<Nombre> = new <tipo>[<dimensión>];
Para el ejemplo del arreglo letras sería:
char[]letras = new char[15];
De nuevo, se ha declarado y creado un arreglo llamado letras, el
cual puede almacenar hasta 15 elementos de tipo char.
Gráficamente:
De esta forma el arreglo se declara y crea, pero aún no se ha
guardado nada en él. Sin embargo, tenga presente que, por
defecto u omisión, cada una de las celdas almacena el valor cero
(0) para arreglos de tipo entero (Int), cero punto cero (0.0) para
arreglos arreglos de tipo real (double). y el valor null para
arreglos de tipo texto (String).
Inicialización, segunda opción:
<Tipo>[ ]<Nombre> = {e1,e2,e3,...eN};
Donde e1, e2,...,eN son N elementos de tipo tipo Tipo. Por
ejemplo, para declarar y crear un arreglo con las vocales, en el
flujograma sería:


En el lenguaje C# sería:
char[ ] vocales = {‘a’, ‘e’, ‘i’, ‘o’, ‘u’};
En este caso se declara y crea un arreglo llamado vocales, el cual
tiene almacenadas las vocales:
De esta forma, el arreglo se inicializa con datos.
Tenga presente que los datos de tipo carácter, como en el
ejemplo, requieren las comillas simples, y los datos de tipo String
requieren las comillas dobles.
Ejemplo 2:
Si se necesita guardar los nombres de algunas ciudades de
colombia:
flujograma:
C#
String[ ] ciudades = {“Bogotá”, “Villavicencio”, “Cali”,


“Medellín”, “Pasto”};

Ejemplo 3:
Si se necesita guardar las ventas diarias de una tienda durante la
última semana, en el flujograma puede declarar y crear el
siguiente arreglo:
flujograma:
double[ ] ventas = new double[7];

Ejemplo 4:
Si se quiere guardar los nombres y la nota definitiva de 15
estudiantes se pueden declarar y crear los siguientes arreglos:

flujograma:


String[ ] nombres = new String[15];
double[ ] notas = new double[15];
Ejemplo 5:
Si se necesita guardar los días de la semana, se puede crear y
declarar el siguiente arreglo:

Flujograma:
String[ ] dias = {“Lunes”, “Martes”, “Miércoles”, “Jueves”, “Viernes”};
Inicialización de un Arreglo
La inicialización es el mecanismo mediante el cual le asignamos
datos a un arreglo. En la segunda opción de inicialización, vimos
cómo declarar y asignar datos a un arreglo. Ahora veremos cómo
asignar información a un arreglo que se ha declarado y creado,
pero no se le ha asignado información (primera opción de
inicialización).
Para guardar un elemento en un arreglo, se usa la instrucción de
asignación, teniendo en cuenta que para acceder a una celda del
arreglo, debe referenciarse mediante su índice.
Tomemos como ejemplo el arreglo v entas.


double[ ] ventas = new double[7];
esta declaración y creación da como resultado lo siguiente:
Si se quiere guardar el valor de la primera venta, con valor de
$15800, se hace lo siguiente:
ventas[0] = 15800;
Ejemplo 6:
Retomando el ejemplo de los nombres y notas de los 15
estudiantes, se quiere un programa que permita pedir esos
nombres y notas.


flujograma:
En lenguaje de programación C#, sería:

private void principal(){
string[] nombres;
double[] notas;
nombres = new string[15];
notas = new double[15];
for(int i=0; i < nombres.length; i++){

nombres[i] = Interaction.InputBox(“Digite el nombre: ”);
notas[i] = double.Parse(Interaction.InputBox(“Digite la nota: ”));
}//Fin del for
}//Fin del subproceso principal
Importante: C# proporciona una función que devuelve el número

de elementos de un arreglo unidimensional. Esta función se
llama length y para usarla solo hay que escribir el nombre del


arreglo. length.
En el ejemplo anterior, para obtener el tamaño del arreglo
nombres sería:
nombres.length
Ejemplo 7:
Ahora suponga que se quiere mostrar un reporte con el nombre y
nota de cada uno de los estudiante, junto con el promedio de los
15 estudiantes.

flujograma:
Para estas dos nuevas necesidades, se crean dos subprocesos: el
primero llamado calcularPromedio, al cual se le envía el arreglo de


notas y devuelve el promedio de las notas de los estudiantes. El
segundo subproceso llamado generarReporte, se le envían los
arreglos de nombres y notas, y devuelve un reporte de tipo texto
con un listado de los nombres y notas de los estudiantes.
El método principal, en el lenguaje C#, sería:

private void principal(){
string[] nombres; //Declara el arreglo de nombres.
double[] notas; //Declara el arreglo de notas.
double promedio;
string reporte;
nombres = new string[15]; //Crea y dimensiona el arreglo de nombres.
notas = new double[15]; //Crea y dimensiona el arreglo de notas.
//Ciclo de lectura para inicializar (o llenar) los arreglos:

}//Fin del for
promedio = calcularPromedio(notas) ;
reporte = generarReporte(nombres, notas);
tbPromedio.Text = promedio.ToString(); //Muestra el promedio en una caja de texto
rtReporte.Text = reporte; //Muestra el reporte en un richTextBox


Subproceso calcularPromedio:
Flujograma
El método, en lenguaje C#, sería:

pubic double calcularPromedio(double[ ] n){
double prom =0;
for(int i=0; i< n.length; i++){
prom += n[i];
}//Fin del for
prom /= n.length;
return prom;
}//Fin del subproceso calcularPromedio.


Flujograma del Subproceso generarReporte:

public String generarReporte(String[] nom,double[ ] n){
String r = “”;
for(int i=0; i< n.length; i++){
r += nom[i] + ”\t” + n[i] + ”\n”;
}//Fin del for
return r;
}//Fin del subproceso generarReporte
Ajuste nota: se quiere hacer un ajuste del 10% a la nota de los
estudiantes. Se debe tener en cuenta que la nota no puede ser
mayor que 5.0. Para dar solución a esta situación, podemos crear
un nuevo subproceso con nombre a justeNota.


Flujograma del subproceso ajusteNota

public void ajusteNota(double[ ] n){
double ajuste;
for(int i=0; i< n.Length; i++){
ajuste = n[i] * 1.10
if(ajuste > 5.0){
n[i] = 5.0;
} //Fin del if
else{
n[i] = ajuste;
} //Fin del else
}//Fin del for
}//Fin método ajusteNota
Este método recibe un arreglo de tipo real con las notas de los
estudiantes y no devuelve nada, ya que el envío de los arreglos a
los métodos se da por referencia; es decir, lo que se envía es la
dirección en memoria, donde se encuentran los datos, y al hacer


modificaciones al arreglo en el método, se están haciendo

modificaciones directamente sobre los arreglos enviados. En el
caso del ejemplo, al modificar los datos del arreglo n, también se
están modificando los datos del arreglo enviado notas ya que se
trata del mismo arreglo: se dice que n es un alias de notas; por lo
tanto, se refiere al mismo arreglo notas.
En el flujograma principal tendríamos:
Observe que en el llamado al subproceso ajusteNota sólo se
indica el nombre del subproceso y, entre paréntesis, va el arreglo
enviado(en este caso notas). Como el subproceso ajusteNota no
devuelve nada, no se tiene una variable para recibir algún
resultado. Sin embargo, el envío del arreglo es por referencia, y
en el subproceso ajusteNota, se modificarán los datos del arreglo
notas.
El método principal, en el lenguaje C#, sería:

public void principal(){
String[] nombres;
double[] notas;


double promedio;
String reporte;
nombres = new String[15];
notas = new double[15];

}//Fin del for
ajusteNota(notas);
promedio = calcularPromedio(notas) ;
reporte = generarReporte(nombres, notas);
tbPromedio.Text = promedio.ToString();
tbReporte.Text = reporte;



ii. Arreglos Bidimensionales (Matrices)
Podemos imaginar una matriz como una tabla compuesta por filas
y columnas, donde la intercesión de una fila con una columna
corresponde con una celda (espacios de memoria), o casillas, en
cada una de las cuales se puede guardar un elemento de una
colección. A cada fila y columna se le asocia un índice. En el caso
del ejemplo siguiente, tenemos 4 filas por 3 columnas, cada una
con sus respectivos índices: 0, 1, 2 y 3 para las filas; y 0, 1 y 2 para
las columnas.
Para referenciar un elemento en la matriz se indica el nombre de la

matriz seguido de [, el índice de la fila, una coma (,), el índice de la
columna y finaliza con ]. Del ejemplo anterior, m[1,2] hace
referencia al elemento de la matriz m que se encuentra en el cruce
de la fila 1 con la columna 2; es decir, el valor 7.
El tamaño de una matriz es el máximo número de elementos que
se pueden guardar en ella, el cual es igual al número de filas
multiplicado por el número de columnas de la misma. En el caso
del ejemplo, el tamaño de la matriz m es 12 = 4 filas * 3 columnas, y
corresponde a las 12 casillas representadas en la figura.
En el lenguaje de programación C#, el tamaño de una matriz se
obtiene con la la propiedad Length escrita después del nombre de
la matriz y el operador punto (.). En nuestro ejemplo, la siguiente

instrucción de C# asigna el tamaño de la matriz m en la variable
tamaño de tipo entero:
int tamaño = m.Length;
Adicionalmente, el lenguaje de programación C# proporciona los

métodos GetLength(0) y GetLength(1) que devuelven el número de
filas y el de columnas, respectivamente. Estos métodos deben ser
precedidos por el nombre de la matriz y el operador punto (.). De
nuevo, para la matriz m, las siguientes instrucciones de C# asignan
el número de filas y número de columnas en las variables enteras
filas y columnas:

int filas = m.GetLength(0);
int columnas = m.GetLength(1);

Operaciones sobre arreglos bidimensionales (Matrices)
Declaración
En el pseudo-lenguaje, una matriz se declara y crea usando el
siguiente formato o plantilla:
<NOMBRE>[ , ] : arreglo [<F>,<C>]

donde:
<NOMBRE> → Corresponde al nombre del arreglo bidimensional
arreglo → indica que se está creando un arreglo.
[<F>,<C>] → es la dimensión del arreglo, donde F es el número de
filas y C es el número de columnas. F y C deben tomar valores
enteros mayores o iguales que 1.


Ejemplo 1: declarar y crear un arreglo bidimensional

En el flujograma:
De esta manera, se declara un arreglo bidimensional llamado

ventas, de tipo real y se crea con 4 filas y 3 columnas; es decir,
tiene un tamaño igual a 12 = 4 * 3 (puede almacenar hasta 12
elementos).
En el lenguaje de programación C# la declaración de la matriz real
ventas, su creación y dimensionamiento se pueden implementar
así:
double[ , ] ventas = new double[4,3];
Una representación gráfica de este arreglo bidimensional ventas

sería:
0.0 0.0 0.0
0.0 0.0 0.0
0.0 0.0 0.0
0.0 0.0 0.0

ventas
Inicialización
Un arreglo bidimensional puede ser declarado e inicializado con


algunos valores válidos.
<Nombre>[ , ] = {{e00, e01,…, e0W}, {e10, e11,…,

e1W},…, {eH0, eH1,…, eHW}};
Donde W = C – 1 y H = F – 1, siendo C el número de

columnas de la matriz y F el número de filas.
En el lenguaje C#, sería:
<Tipo>[ , ] <Nombre>= {{e00, e01,…, e0W}, {e10, e11,…,

e1W},…, {eH0, eH1,…, eHW}};
Para declarar e inicializar un arreglo bidimensional incluyendo

datos, cada par de corchetes { } corresponde a una fila de la
matriz y cada uno de sus elementos debe ir separado por una
coma. De la misma manera, cada fila también debe ir separada
por una coma.
Ejemplo 2: declarar e inicializar un arreglo bidimensional

En el flujograma:
Declaramos un arreglo bidimensional llamado letras con 3 filas y

3 columnas, donde se almacenan datos de tipo carácter. El
tamaño de la matriz letras es 9, es decir puede almacenar hasta 9
elementos. En este caso en particular el arreglo ya tiene datos
asignados.
En el lenguaje C#, sería:
char[ , ] letras = {{'a', 'b', 'c'}, {'d', 'e','f'}, {'g', 'h','i'} } ;


En este caso:
char[ , ] letras = { {'a', 'b', 'c'}, {'d', 'e','f'}, {'g', 'h','i'} } ;

fila 0 fila 1 fila 2
La representación gráfica de este arreglo bidimensional letras
sería:
‘a’ ‘b’ ‘c’
‘d’ ‘e’ ‘f’
‘g’ ‘h’ ‘i’

letras
Recorrido de una matriz

Una matriz se puede recorrer de dos formas: recorrido por filas y
recorrido por columnas, todo depende de la necesidad.
Observemos la matriz letras. Si se la recorre por filas y se
guardan sus elementos en una variable de tipo texto, daría como
resultado:
a b c d e f g h i
Ahora, si el recorrido es por columnas el resultado sería:
a d g b e h c f i
Como se puede observar, cada recorrido da un resultado

diferente.
Observemos el recorrido por filas en el siguiente flujograma:


Prueba de escritorio recorrido filas
letras f c datos
{{'a', 'b', 'c'}, {'d', 'e', 'f'}, {'g', 'h', 'i'} } 0 0 “”
1 1 a
2 2 a b
3 3 a b c
0 a b c d
1 a b c d e
2 a b c d e f
3 a b c d e f g

0 a b c d e f g h
1 a b c d e f g h i
2
3

datos = “a b c d e f g h i” corresponde al resultado de

recorrido en filas.
Ejercicio: ahora que ya sabe cómo es el recorrido por filas,
modifique el flujograma para que realice un recorrido por
columnas. Recuerde hacer la prueba de escritorio.
Ejemplo 3: La división de promoción y prevención de desastres

del Suroccidente Colombiano, desea llevar un control sobre la
cantidad de lluvias(o precipitación) que se ha producido en los 6
primeros meses del año en 5 de sus departamentos (Valle, Cauca,
Nariño, Putumayo y Chocó). Los nombres de los departamentos
se encuentran almacenados en un arreglo unidimensional de tipo
texto (String) de tamaño 5, y la información sobre las
precipitaciones se encuentra almacenada en una matriz de tipo
real (double) de 5 filas y 6 columnas, donde cada fila se asocia a
un departamento, y cada columna a uno de los primeros seis
meses del año, como se muestra en la siguiente tabla:


Se requiere un programa para simular la cantidad de lluvia
(precipitación), que cumpla con los siguientes requerimientos.
● Realizar un subproceso que llene automáticamente la

matriz de lluvias con números aleatorios decimales entre
0.0 y 100. Cada valor en la matriz representa la cantidad de
lluvia (o precipitación), en centímetros cúbicos, en un
departamento en determinado mes.
● Realizar un subproceso que genere un reporte con los
datos de las lluvias como se muestra en la tabla 1.
● Realizar un subproceso que dado un mes devuelva el
promedio de lluvias en ese mes.
● Realizar un subproceso que dado un departamento
devuelva el promedio de lluvias de ese departamento en
ese semestre.



Flujograma del proceso principal
En el lenguaje de programación C#, sería:

public void principal(){
string[] departamentos = {“Cauca”, “Choco”,”Nariño”,”Putumayo”,”Valle”}
double[,] precipitaciones = new double[5,6];
llenarPrecipitaciones(precipitaciones, departamentos);
reporte = generarReporte(precipitaciones, departamentos);
int mes = Int.Parse(Interaction.InputBox(“Digite el número del mes: ”));
double promedioMes = calcularPromedioMes(precipitaciones, mes);
int departamento= Int.Parse(Interaction.InputBox(“Digite el número del dpto: ”));
double promedioDepartamento =calcularPromedioDpto(precipitaciones, departamento);
tbReporte.Text = reporte;
tbPromedioMes.Text = promedioMes.ToString();
tbPromedioDpto.Text = promedioDepartamento.ToString();


Flujograma subproceso llenarPrecipitaciones

public void llenarPrecipitaciones(double[ , ]p){
Random r = new Random();
for(int f = 0; f < filas de p; f++){
for(int c=0; c< columnas de p; c++){
p[f,c] = (r.NextDouble() * (100 - 0 + 1)) + 0;
}//Fin del for
}//Fin del for
}//Fin del subproceso llenarPrecipitaciones


Flujograma del Subproceso generarReporte

public String generarReporte(double[ , ] p, String[] d){
string r = “”;
for(int f = 0; f < filas de p; f++){
r = r + d[f]+”\t”;
r = r + p[f,c]+ ”\t”;
}//Fin del for
r = r + ”\n”
}//Fin del for
return r;
}//Fin del subproceso gemerarReporte


Flujograma del Subproceso calcularPromedioMes

public double calcularPromedioMes(double[ , ] p, int m){
double pm = 0;
for(int f=0; f< filas de p; f++){
pm = pm + p[f,m];
}//Fin del for
pm = pm / f;
return pm;
}//Fin del subproceso calcularPromedioMes
Flujograma del Subproceso calcularPromedioDpto



public double calcularPromedioDpto(double[ , ] p, int d){
double pd = 0;
pd = pd + p[d,c];
}//Fin del for
pd = pd / c;
return pd;
}//Fin del subproceso calcularPromedioDpto


Módulo Algoritmia y Programación

Cargado por

Copyright:

Formatos disponibles

Módulo Algoritmia y Programación

Cargado por

Información del documento

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

Módulo Algoritmia y Programación

Cargado por

Copyright:

Formatos disponibles

Tabla de Contenido

Introducción a la Programación 10

Curso: Algoritmia y Programación 1

Curso: Algoritmia y Programación 2

Algunos lenguajes pueden emplear otros símbolos para representar las

diferentes operaciones o pueden incluir nuevos operadores como el de

Cuando se encuentran dos o más operadores del mismo nivel de prioridad, las

4+8*2–6/2 Para resolver esta expresión se realizaría primero

(4 + 8) * (2 – 6) / 2 En este caso se ha alterado la ​prioridad gracias al

Curso: Algoritmia y Programación 4

prioridades harán que se tenga el resultado que realmente se espera.

10 / 4​ dará como resultado 2​ ​, ya que los dos números son enteros

Estos operadores son los que permiten establecer algún tipo de relación entre

10 >= 10 Tendrá resultado Verdadero

Verdadero Verdadero Verdadero

Algunas operaciones matemáticas comunes, no tienen representación en los

Curso: Algoritmia y Programación 9

II. Introducción a la Programación

-Escribir un programa, implica necesariamente, hacer un algoritmo-

Digamos que debemos transportar a 3 personas, no importa cuánto tiempo se

● Alternativa 1: Tomar un taxi. Permite transportar a 3 personas pero con seguridad

Una vez encontramos alternativas válidas podemos seleccionar una, vamos a

Este es un ejemplo bastante simple, pero representa nuestra forma de pensar

La primera etapa en el proceso de programación tiene diferentes nombres, en

En la Universidad de la Región se quiere desarrollar un programa que permita

Curso: Algoritmia y Programación 13

Para efectos posteriores de validar los datos, vamos a incluir el rango de

○ Número de horas totales programadas en el curso. (mayor a 0)

Curso: Algoritmia y Programación 14

mostrado al usuario, por lo tanto no se considera dato de salida.

Curso: Algoritmia y Programación 15

Continuando con nuestro ejemplo y considerando los datos de entrada y

Curso: Algoritmia y Programación 16

salida definidos, pasaremos a desarrollar el diseño del mismo.

El siguiente paso es realizar la implementación del algoritmo, es decir, traducir

Elementos básicos de programación

Los elementos básicos de programación se describen a continuación:

● Cadenas​: algunos lenguajes disponen de un tipo de dato

nombre=“Miguel” asigna la cadena Miguel a la variable

promedio = nota asigna a la variable promedio el valor

3=x es una expresión no válida, porque no

Operaciones de escritura: son las operaciones que permiten presentar

Decisiones​: son operaciones que permiten definir un conjunto de

NOTA: Aunque pueden existir variaciones, en general, los métodos

programación tienen la posibilidad de retornar un solo dato.

La última actividad del proceso de desarrollo de software es la de pruebas, en

Cada prueba incluye:

● Una descripción de la característica o funcionalidad que se desea probar.

Curso: Algoritmia y Programación 22

III. Introducción al Lenguaje C#

Inicialmente se desarrollará la GUI, agregando esencialmente: labels

Curso: Algoritmia y Programación 23

El código del programa aparece en otra ventana y tiene una estructura similar

Lectura de variables de entrada desde una GUI.

Suponiendo que la caja de texto que contiene el dato se llama Control:

Lectura de cadenas String variable​ = Control.Text​;

Ej​: S​ tring nombre​ = textBoxNombre​.​Text;

Escritura (salida) de variables de entrada desde una GUI.

Suponiendo que la caja de texto que va a contener el dato se llama Control:

Mostrar una cadena fija o constante Control.Text​ = “Constante de cadena”;

(4 + 8) * (2 – 6) / 2 En este caso se ha alterado la prioridad gracias al

10 / 4 dará como resultado 2 , ya que los dos números son enteros

● Cadenas: algunos lenguajes disponen de un tipo de dato

Decisiones: son operaciones que permiten definir un conjunto de

Lectura de cadenas String variable = Control.Text;

Ej: S tring nombre = textBoxNombre.Text;

Mostrar una cadena fija o constante Control.Text = “Constante de cadena”;

Limpiar componentes gráficos Cajas de texto Control.Clear();

OBSERVACIONES: Es importante considerar los siguientes aspectos:

Ejemplo 1: Calcular la longitud de una circunferencia si el radio es positivo.

if ( radio > 0 ){

Ejemplo 4: Dada la edad de una persona, imprimir un mensaje indicando si es

if ( edad >= 18 )

Ejemplo: Se requiere un programa que permita leer 100 números y obtener la

or(instrucciones iniciales; condición; instrucciones finales) {

● Instrucciones iniciales: son las primeras instrucciones que se

else { //si no es positivo ni negativo, debe ser cero.

Ejemplo 3: Se requiere un programa que lea las edades de 150 estudiantes de

Ejemplo 1: Se requiere un programa que muestre los números de 1 a 5

Ejemplo 3: Se requiere un programa que lea las edades de 150 estudiantes de

IMPORTANTE: Como se puede observar, esta clase de ciclo inicia preguntando

Ejemplo 1: Se requiere un programa que muestre los números de 1 a 5