UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERIA Y ARQUITECTURA

ESCUELA DE INGENIERIA DE SISTEMAS INFORMATICOS
INTRODUCCION A LA INFORMATICA – Ciclo I
GUIA 3: Estructuras de Control Secuenciales

Objetivo General:
Crear programas básicos en Lenguaje C#, que ejecuten las tareas fundamentales de
entrada, proceso y salida de datos; resolviendo problemas simples donde se involucre el uso
de operadores aritméticos y “funciones matemáticas” auxiliándose de la herramienta para
desarrollo de aplicaciones: IDE Visual Studio 2015 como primera experiencia en la
programación de aplicaciones.

Objetivos Específicos:
• Demostrar las tareas básicas o fundamentales que realiza un programa.
• Implementar instrucciones básicas de entrada, proceso y salida en el Lenguaje C#
• Utilizar la librería System, específicamente las clases Console y Math, para la
programación de la entrada, proceso y salida de algoritmos básicos.
• Identificar las partes que componen o integran el programa.
• Hacer declaración de constantes y variables al inicio del programa, usando nombres
significativos (mnemotécnicos) y empleando las convenciones de nombrado indicadas en
su clase teórica.
• Identificar el programa a realizar detallando función, carnet, nombre completo y número
de laboratorio; haciendo uso de comentarios al inicio de la clase Program.
• Aplicar métodos de lectura y conversión de datos de entrada según el tipo de dato de la
variable de entrada.
• Conocer y aplicar los operadores básicos del lenguaje C# y las funciones matemáticas de
la clase Math; aplicando la jerarquía de operadores para traducir las “fórmulas de libro”
a las expresiones aritméticas o expresiones de programación equivalentes en C#
• Conocer y aplicar la técnica de salida de datos por medio de plantilla de salida con
elementos de formato indizados con los métodos Write y WriteLine de la clase Console.
• Presentar los mensajes informativos como corresponde tanto durante la entrada de datos
como durante la salida de datos, así como también colocar los comentarios según
corresponda.

Introducción:
Esta Guía consta de cinco partes. La primera parte muestra el uso de los operadores
aritméticos con su respectiva jerarquía, detallando como pasar de una expresión matemática
a una expresión lineal comprensible para el computador; la segunda parte es la descripción
de las tareas básicas de todo programa; la parte III da a conocer el procedimiento a seguir
para crear programas en C#; luego, en la cuarta parte desarrolla un ejemplo siguiendo el
procedimiento descrito; y por último, en la quinta parte, se brinda un listado de Ejercicios
Propuestos, que el estudiante debe desarrollar a manera de estudio.

1
Metodología: Leer y analizar las Guías de Laboratorio antes de la sesión correspondiente.
Esta responsabilidad le permitirá comprender mejor los temas tratados y le facilitará
grandemente su aprendizaje.

El docente instructor explicará brevemente la Parte I, II y III y IV de esta Guía; después, el

docente instructor pedirá a los estudiantes que desarrollen en parejas: 3 ejercicios de
conversión de expresiones, 2 de evaluación de expresiones y 1 de codificación. El ejercicio
de lógica puede ser elaborado opcionalmente o como tarea exaula.

Parte I. Operadores Aritméticos

Un operador en C# e s un símbolo formado por uno o más caracteres que permite realizar
una determinada operación entre uno o más datos y produce un resultado.

A continuación se describen cuáles son los operadores incluidos en el lenguaje, clasificados

según el tipo de operaciones que permiten realizar, aunque hay que tener en cuenta que C#
permite la redefinición del significado de la mayoría de los operadores según el tipo de dato
sobre el que se apliquen, por lo que, lo que aquí se menciona, se corresponde con los usos
más comunes de los mismos.

Los operadores aritméticos son signos que nos indican un cálculo, como suma o
multiplicación, entre otros; a continuación se presentan los que utilizaremos en esta
asignatura, su representación puede variar, de acuerdo al lenguaje de programación que se
utilice. La simbología utilizada en los siguientes ejemplos está basada en la sintaxis del
Lenguaje de Programación C#:

Operación Símbolo Tipo de resultado Ejemplo

Cambio de Signo - Entero o real -(-2)
(Negativo)
Multiplicación * Entero o real 3*A
Division / Real A/B
Suma + Entero o real A+3
Resta - Entero o real B–2
Residuo de división % Entero 15%2
(División residual)

Cuando se trabaja con operadores debemos tener en cuenta, que el orden de los operadores
que se sigue en C# se basa en la jerarquía de operaciones, la cual se muestra en la página
siguiente.

Jerarquía de operaciones.

Para realizar cualquier tipo de ejercicios donde se involucren expresiones aritméticas, se

tendrá que respetar la siguiente jerarquía de operaciones:

2
 + Operadores Asociatividad Tipo
() Izquierda a derecha Paréntesis
Funciones Izquierda a derecha Funciones de C#
* / % Izquierda a derecha Multiplicativos
+ - Izquierda a derecha Adición
< <= > >= Izquierda a derecha Relacionales
== != Izquierda a derecha Igualdad
- = Derecha a Izquierda Asignación

Asociatividad: En palabras “Informales”, se refiere a la manera de realizar las operaciones

del mismo nivel de jerarquía, esto quiere decir, que si se tienen que realizar dos o más
operaciones del mismo nivel jerárquico al mismo tiempo, la forma de operarlas nos la
proporciona la Asociatividad de ese nivel.

Así, si se tiene que realizar una suma y una resta al mismo tiempo, hay que referirnos a la
Asociatividad de ese nivel, la cual es, según la tabla de jerarquías, de “Izquierda a derecha”,
lo que en otras palabras quiere decir “la operación que está más a la izquierda se realiza
primero”, entonces si por ejemplo se tiene la operación “5 + 3 – 2”, se realizara primero la
suma y después la resta dando como resultado 6.

A continuación se realizan 3 ejemplos acerca de expresiones aritméticas.

3
Solución:

V=1/3.0*h*(B1+sqrt(B1*B2)+B2)

El programa correspondiente para probar esta expresión quedaría de la siguiente manera:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExpresionesAritmeticas
{
class Program
{
static void Main(string[] args)
{
Console.Title = "Expresiones Aritméticas";
Console.WriteLine("Expresiones Aritméticas");
Console.WriteLine("Autor: Juan Pérez");

//Declaración de Variables
double b1, b2, v,h;

//entrada de datos
Console.WriteLine("Ingrese el valor de h");
h = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el valor de B1");
b1 = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el valor de B2");
b2 = double.Parse(Console.ReadLine());

//Expresión Aritmética (Proceso)

v = 1 / 3.0 * h * (b1 + Math.Sqrt(b1 * b2) + b2);
/* se pone 3.0 para hacer el dato real, si se pone entero no considera los
decimales, por lo que devuelve cero.*/

//Salida de datos
Console.WriteLine("Valor de la expresión Aritmética: {0:####.##}", v);
Console.ReadKey();
}
}
}

Ejemplo 3:

Utilice la Jerarquía de Operadores para evaluar la expresión siguiente :

4
b=w- ((x+ pow (2,2)) –(3-1)+2 (y+((8+3)-(z-10))))
sabiendo que: w=250; x=6; y=16; z=12

sustituyendo las variables por sus valores asociados:

b= 250 – ((6+pow(2,2)) – (3-1) + 2 (16+((8+3)-(12-10))))

Evaluar, observe como se manejan los paréntesis y el orden en que se ejecutan las
operaciones, una a la vez.

b= 250 – ((6+pow(2,2)) – (3-1) + 2 *(16+((8+3)-(12-10))))

b= 250 – ((6+4.0) – (3-1) + 2*(16+((8+3)-(12-10))))
b= 250 – (10.0 – (3-1) + 2*(16+((8+3)-(12-10))))
b= 250 – (10.0 – 2 + 2*(16+((8+3)-(12-10))))
b= 250 – (10.0 – 2 + 2*(16+(11-(12-10))))
b= 250 – (10.0 – 2 + 2*(16+(11-2)))
b= 250 – (10.0 – 2 + 2*(16+9))
b= 250 – (10.0 – 2 + 2 *25)
b= 250 – (10.0 – 2 + 50)
b= 250 – (8.0 + 50)
b= 250 – 58.0
b= 192.0

El resultado es real, por lo que la variable b debe ser de ese tipo.

Parte II. Tareas Básicas de un Programa

Para lograr un determinado objetivo y sin importar qué paradigma de programación ó qué
metodología de solución se utilice, todo programa presenta las siguientes partes o
elementos: Entrada, Proceso y Salida. En cada parte el programa realiza las tareas
correspondientes a fin de obtener los datos necesarios para realizar el proceso requerido y
proporcionar los resultados esperados, para los cuales fue creado. Las tareas mencionadas
deben ser programadas buscando resolver la situación planteada. Observar la ilustración
gráfica siguiente:

En esta Práctica: la entrada, proceso y salida estarán concentradas en un solo método, Main.
Pero, en próximas sesiones de laboratorio, dichas tareas pueden ser realizadas de manera
separada y por tantos métodos como requiera el diseño de la solución, dependiendo de la
complejidad del problema a resolver.

5
Para esta Práctica, se va a emplear y seguir un procedimiento, descrito en la Parte II y
aplicado en la Parte III.

Parte III. Procedimiento para la Creación de un Programa

Para esta Guía, no se aplicará formalmente una metodología, ya que sólo se seguirá el
procedimiento indicado a continuación. Pero, posteriormente, en las próximas prácticas, se
va a aplicar la Metodología de Solución de Problemas de la Unidad III

Los pasos a seguir son los siguientes:

1. Dado un ejercicio, leer y analizar el enunciado del problema.

2. Crear una nueva solución/proyecto en el IDE Visual Studio, en la ubicación y con el
nombre adecuado según la Guía y ejercicio solicitado, todo de acuerdo a las indicaciones
ya dadas en la sesión de práctica anterior (Guía No.2).
3. Declarar las constantes con sus valores y tipo de dato respectivo. Sólo SÍ EXISTEN
4. Declarar las variables con el tipo de dato que corresponda y un nombre mnemotécnico o
descriptivo, siguiendo las indicaciones dadas en la clase teórica. No importa si son de
entrada o salida, para el lenguaje todas son variables y no distingue; en otras palabras,
es el programador el que las clasifica como: variables de entrada o variables de salida.
5. Identificar el programa en pantalla: escribir dentro de comentarios la función del
programa, carnet y nombre completo del autor (cada alumno) y número de laboratorio.
6. Programar la entrada de datos.
7. Programar el proceso de datos.
8. Programar la salida de datos.
9. Compilar para verificar la sintáxis, depurar (buscar y corregir errores si los hay) y ejecutar
la solución
10 Verificar que se obtengan los resultados esperados; de lo contrario, revisar los pasos
anteriores.
11 Guardar. De preferencia realice esta acción después de cada paso para garantizar que
no perderá su trabajo en caso de falta de energía.
12 Cerrar la solución y finalizar.

Parte IV. Ejemplo

Enunciado. Dada la masa de un cuerpo en sistema internacional, se pide calcular el peso
del cuerpo y desplegar el resultado, siempre en sistema internacional.
1. Leer el enunciado del ejemplo e interpretar lo que se está pidiendo, identificando los
cálculos a realizar, qué resultados se deberían producir y los datos necesarios para
producir dichos resultados en la cantidad y calidad requeridos. En este sentido, se debe
razonar que en el sistema internacional la masa se representa con m y viene dada en
Kilogramos y debe ser un valor positivo, mientras que el peso se representa con w y está
dado en Kilogramos por metros sobre segundos al cuadrado (Newton) y que la fórmula
del peso es igual a la masa multiplicada por la constante de gravedad, representada por
g y cuyo valor es igual a 9.8 mts/seg.2 En resumen: w = m . g

6
 Recordar que las variables y constantes de un programa nunca almacenan unidades; es
decir, son adimensionales. Así que, siempre que se haga un programa, es
RESPONSABILIDAD de su autor: dar a conocer por medio de un MENSAJE en
pantalla, las unidades tanto al momento de solicitar el ingreso de los datos como al
momento de dar los resultados.

También se debe considerar que :

a) El programa debe solicitar el valor de la masa m, mostrando un mensaje previo en

pantalla, de lo contrario quien use el programa no sabrá qué debe de ingresar. Dicho
valor debe ser positivo (lo cual debe ser indicado en el mismo mensaje) y que la
unidad del valor a introducir es: Kilogramos (y que también debe estar indicado en el
mensaje).

b) Debido a que el valor de la masa es cambiante en cada ejecución del programa, se

necesitará una variable para guardarlo y un nombre para dicha variable; y dado que la
masa es un valor real que puede llegar a ser muy grande el tipo de dato más
adecuado para la variable es double.

c) Se requiere una constante de gravedad, con un valor igual a 9.8 que deberá ser
declarada, especificando su nombre y tipo. El tipo de dato más adecuado es float,
dado que es un valor fijo y pequeño.

d) Se debe mostrar el peso w, como salida con sus respectivas unidades, las cuales se
deben indicar en el mensaje de salida junto con el valor. Para ello, se necesita
declarar una variable (seleccionando un nombre descriptivo y un tipo), para guardar la
salida o resultado, a fin de poder desplegarla en el momento que sea necesario. Este
valor es el resultado de aplicar la fórmula de libro, escrita como una expresión de
programación, de manera computacional: w = m . g

Cuando se represente la fórmula en el programa mediante una expresión de

programación, se deberá hacer uso de los nombres de variables y de constante tal y
como han sido declarados en el programa, y no los nombres usados en la “fórmula de
libro”, cabe recordar que C# es lenguaje “case sensitive” (distingue entre mayúsculas y
minúsculas).

2. Crear un Nuevo Proyecto de nombre: Guia3Ejemplo dentro de la Carpeta Guia3

3. Bajo la llave de apertura del método Main, declarar las constantes, sí las hay. Para este
caso, escribir las siguientes 4 líneas en el lugar mencionado:
//Declaración de Constantes
const float GRAVEDAD = 9.8f;
//La letra f junto a 9.8 indica el tipo float de la constante
//Observar que no se agregan las unidades de la constante de gravedad

La primera línea es un comentario, que sirve para documentar el programa y saber que
es la parte que corresponde a la declaración de constante(s). Cabe mencionar que los
comentarios son ignorados completamente por el compilador y que sólo son una ayuda
para el programador.

7
 La segunda línea es la declaración de la constante. Observar que primero se debe
colocar la palabra const seguida por el tipo de dato, en este caso float y a continuación
colocar el nombre de la constante, la cual se ha decidido nombrar como GRAVEDAD.
Justo después del nombre de constante (GRAVEDAD), se debe colocar el signo = y
luego el valor que se le asignará (9.8 sin unidades), finalizando la instrucción con un ;

NOTACION: El nombre que se le dé a una constante, en este o en cualquier otro

programa futuro, DEBE ser significativo y escrito todo en Mayúsculas: estilo ALL-
CASE. La cual es una norma que se adoptará para la escritura de nombres de
constantes.

4. Posteriormente a las líneas de declaración de constantes, se declararán las variables,

usando el tipo de dato que corresponda y haciendo uso de un nombre mnemotécnico o
descriptivo. Dejando una línea de por medio, escribir las siguientes 2 líneas:
//Declaración de Variables
double masa, peso;

La primera línea es un comentario que indica que a continuación comienza la parte que
corresponde a la declaración de variables. La segunda línea declara 2 variables de tipo
double: masa y peso, finalizando la instrucción con ; Observar que los nombres son
significativos y dan una idea clara, sobre el dato que contendrán o guardarán.
La declaración de variables, no distingue entre las que serán utilizadas para entrada o
salida. Tomar en cuenta, que en esta sección del programa, se deberán escribir las
declaraciones necesarias para representar todas las variables de la solución, tanto las de
entrada como las de salida. Para este caso, sólo se tienen 2 variables y ambas de tipo
double: masa que es de entrada y peso que es de salida

5. Digitar la identificación del programa, la cual será mostrada en pantalla para dar
información de la solución en el momento que se inicie la ejecución y que permita
identificar el proyecto, programa y autor del mismo. A continuación ubíquese justo abajo
de la declaración de variables (masa, peso), dejando una línea de por medio. Escriba a
continuación las siguientes 3 líneas: (pero reemplazando AB16777 por su carnet y
también los apellidos y nombres que aparecen por los suyos; al igual que el Grupo de
Laboratorio).
//Identificación del Programa en Pantalla
Console.WriteLine("CarnetGuia3Ejemplo: Cálculo del Peso de un cuerpo");
Console.WriteLine("Autor: Amaya Buendía, María Teresa GL:07 \n");

Con las líneas anteriores se mostrará un “texto” que describe la “función” que
desempeña la solución y quien la desarrolló (carnet, nombre completo y grupo de
laboratorio). Cuando desarrolle sus propios ejercicios en ésta y futuras prácticas, deberá
SIEMPRE colocar por Ud. mismo un texto descriptivo para cada programa.

6. En cuanto a la entrada de datos, se debe ser consciente de que antes de leer datos de
entrada (digitados por el teclado); es necesario proporcionar al futuro usuario del
programa la información (por medio de mensajes en pantalla) que le oriente en cuanto a:
a) qué debe ingresar, b) las restricciones que debe cumplir el dato ingresado (si es

8
que existen restricciones) y c) las unidades del dato a ingresar (si es aplicable a dicho
dato).

Recordar que siempre que esté programando entradas de datos que NO SEAN de tipo
alfanumérico; es decir, no son datos de carácter ni son datos de cadena de caracteres.
Se deberá realizar además de la lectura, una “conversión de datos”, debido a que,
TODAS las lecturas de datos por teclado se realizan como lectura de datos
alfanuméricos de cadena de caracteres. Lo anterior implica que cuando se requieran
datos no alfanuméricos, deberán ser convertidos al tipo de dato correspondiente, como
se ilustra a continuación.

Ubícarse justo abajo de la Identificación del Programa, dejando una línea de por medio y
escribir las siguientes 3 líneas de código:
//Entrada de Datos
Console.WriteLine("Ingrese la masa (valor positivo en Kgs): ");
masa = double.Parse( Console.ReadLine() );

La primera línea es un comentario, para indicar que inicia el bloque que representa la
entrada de datos del programa. La segunda línea es el mensaje de “cortesía” al usuario,
para que sepa QUÉ debe ingresar, RESTRICCIÓN que debe de cumplir y las
UNIDADES que representa el valor ingresado. Este mensaje deberá aparecer en
pantalla, justo antes de que se ejecute la instrucción para lectura.

En la tercera línea, observar que a la variable masa se le asigna por medio del signo = el
resultado de la expresión double.Parse( Console.ReadLine() ) . Todas las lecturas por
teclado reciben datos alfanuméricos, el método que hace la lectura propiamente es
Console.ReadLine(), donde quiera que se coloque la llamada al método ReadLine( ), de
la clase Console; se obtendrá una cadena de caracteres ingresada por teclado. Dicha
cadena debe ser procesada “analizada” del inglés Parse, antes de ser asignada a una
variable numérica.

Prestar atención a lo siguiente: Siempre que se deseen “leer” valores numéricos,

se deberá utilizar el tipo de dato de la variable a la cual se le va a asignar el valor
numérico, en este caso es double, seguido por un . y por el nombre de método
Parse y luego entre paréntesis, se colocará la lectura por teclado usando la llamada
a Console.ReadLine() teniendo cuidado de cerrar bien los paréntesis y poner el
punto y coma al final. Como se muestra a continuación:

masa = double.Parse( Console.ReadLine() );

Sólo para poner otro ejemplo: suponer que existe una variable declarada así:
int distanciaX;
Para realizar la lectura de dicha variable por teclado, la instrucción quedaría así:
distanciaX = int.Parse( Console.ReadLine( ) );

Cabe mencionar que esta no es la única forma de hacer la lectura de variables para
datos numéricos y que existen muchas formas y técnicas para hacerlo, pero en esta Guía
es la que será utilizada.

9
7. Para programar el proceso de datos, ubícarse bajo la entrada de datos del programa,
dejando una línea de por medio, escribir las siguientes 2 líneas de código:
//Proceso de Datos
peso = masa * GRAVEDAD;

La primera línea, es el comentario que marca el inicio del proceso de dados. En la

segunda línea se realiza el cálculo de los resultados esperados y por los cuales se ha
codificado este programa, mediante una expresión: peso = masa * GRAVEDAD;

De lo anterior, se debe aprender que: la variable que almacenará un resultado

siempre debe ir a la izquierda del signo igual y que a la derecha del signo igual
siempre va una expresión cuyo resultado se va almacenar en la variable que va a la
izquierda del signo =

Siempre que se programa, se debe tener claro que las “fórmulas” que se pondrán en el
programa no son las mismas del enunciado del problema o no son las mismas tal cual
aparecen en los libros; éstas deberán ser reescritas en el lenguaje de programación C#,
utilizando los operadores, funciones, jerarquía y nomenclatura tal como se le ha indicado
en las clases teóricas; incluyendo y siguiendo las buenas prácticas de programación.

8. En cuanto a la salida de datos, debemos estar conscientes de que se debe proporcionar

no sólo el resultado (valor numérico), sino que se debe informar al usuario QUÉ UNIDAD
corresponde al valor que está observando (el valor no importa de qué tipo sea,
alfanumérico o numérico). Recordar que sólo si el programador considera conveniente o
si el problema (enunciado) lo pide, se deben desplegar en la pantalla las variables de
entrada. Por ejemplo, para este ejemplo, se despliega el valor de la masa (variable de
entrada) y el valor de el peso (variable de salida) en la “salida de datos”.

Para programar la salida de datos, ubícarse bajo el proceso de datos del programa,
dejando una línea de por medio, escribir las siguientes 2 líneas de código:
//Salidad de Datos
Console.Write("Masa:{0:####.##}Kgs Peso:{1:####.##}Newton", masa, peso);

La primera línea es el comentario que indica que inicia la salida de datos y la segunda
línea es el despliegue de resultados en pantalla, por medio de una plantilla de salida.

Existen muchos métodos y técnicas de programar la salida de datos, pero en esta Guía
se empleará la técnica de “Plantilla de Salida con Elementos de Formato Indexados”
en combinación con el método Write o WriteLine de la clase Console.

La Plantilla de Salida con Elementos de Formato Indexados, consiste en “escribir”

una cadena alfanumérica con el texto que se desea que aparezca en pantalla y aquellas
partes del texto que son variantes o que cambian en cada ejecución se representarán por
un elemento de formato, esta cadena debe ir seguida por los nombres de variables a
imprimir separadas por comas.

Un elemento de formato debe estar delimitado por un par de llaves y dentro de las
llaves se debe colocar el “índice” del elemento (posición que ocupa en la lista) seguido
por dos puntos: y el formato que debe tener el valor en pantalla. Ejemplo: {0:####.##}

10
 El índice es un valor numérico empezando en 0 para el elemento de formato más a la
izquierda y aumentando 1 con cada elemento de formato, a medida que se desplaza a la
derecha.

La lista, es la lista de nombres de variables a imprimir en la salida en orden y separadas

por comas dentro de la llamada a Write o WriteLine

Formato: hay muchos formatos disponibles pero sólo se va a utilizar el numérico, usando
el carácter # debe indicar la forma que presentará la salida combinando con puntos o
comas. Por ejemplo:
Console.Write("Masa:{0:####.##}Kgs Peso:{1:####.##} Newton",masa,peso);

Observar que el primer elemento de formato es {0:####.##} este indica que en esa
posición irá el valor de la variable que ocupe la posición cero en la lista, que es masa y
que debe imprimirse con 4 dígitos enteros y dos decimales.

Mientras que el segundo elemento de formato es {1:####.##} este indica que en esa
posición irá el valor de la variable que ocupe la posición uno en la lista que para el caso
es peso y que se debe imprimir con 4 dígitos enteros y 2 decimales.
NOTA: si desea que se observen los ceros decimales cuando el resultado es “entero”, se
debe poner 00 en vez de ## así: {0:####.00}
Agregar la siguiente instrucción antes de la llave de cierre del método Main:
Console.ReadKey();

Luego del despliegue de los datos de salida, normalmente, el programa se cierra y no se

logran visualizar los resultados. Esto se resuelve colocando una “instrucción de lectura”
con lo cual se “obliga” al programa a detenerse (realiza una pausa obligatoria), hasta que
se presione una tecla en caso de usar Console.ReadKey( ) o hasta que se presione
enter en el caso de Console.ReadLine( )
9. Compilar, depurar y ejecutar la solución
10. Verificar que se obtienen los resultados esperados.
11. Guardar la solución.
12. Cerrar la solución y finalizar.

Finalmente, el programa (código fuente) quedará similar a:

11
Ilustración de la Ejecución del Programa:

12
Parte V. Ejercicios Propuestos
A continuación, se presenta una serie de ejercicios propuestos. Como parte de esta práctica
debe desarrollar por Ud. mismo 4 de estos ejercicios, indicados por su docente instructor.

Ejercicio de Lógica

1. Las Semillas del Perico (no es necesario programar)

Un perico tiene una bolsa con bastantes semillas, cada mañana su amo le añade 100
semillas exactamente en la bolsa. Luego, durante el día, el perico se come la mitad de
las semillas que encuentra en la bolsa y deja la otra mitad.

Deduzca una fórmula matemática para encontrar en número de semillas que deja el
perico en un día y diseñe su respectiva expresión aritmética.

Ejercicios de Construcción de Expresiones aritméticas en programación.

Ejercicios de Evaluación de expresiones aritméticas.

Nota: Los cálculos con números reales se trabajarán con una precisión de 2 dígitos en la
parte fraccionaria.

13
Ejercicios de Tareas básicas de un programa.

1. Calcular la distancia entre 2 puntos en la recta numérica dados cada uno de los puntos
en unidades lineales, donde la distancia está dada por: d = |x2 - x1|

2. Calcular la distancia entre 2 puntos en el plano dadas las coordenadas x,y de cada uno
Fórmula:

14
3. La energía potencial gravitacional es la energía que posee un cuerpo, debido a su
posición en un campo gravitacional. Calcular la energía potencial gravitacional terrestre
para un cuerpo DADAS la masa m y una determinada altura h de la tierra. La fórmula es
Epg = w.h, donde el peso w = m.g; es decir, masa m por gravedad g.

4. Calcular el área de un cubo sabiendo que la fórmula es A=6 x aristas 2

5. Convertir una temperatura en grados Fahrenheit a Celsius utilizando las siguiente

fórmula: °F = °C × 9/5 + 32

6. Diseñar un programa que lea cuatro números, y calcule la suma de los dos primeros y
el producto del tercero y el cuarto.
7. Leer dos números flotantes que corresponden a la longitud de los dos catetos de un
triángulo rectángulo. Calcular y mostrar el valor de la hipotenusa y el perímetro del
triángulo.
8. Calcular y mostrar la distancia entre dos puntos de una recta, dado el valor de 2 puntos
ingresados por teclado y dada una cadena de caracteres ingresada por teclado,
conteniendo la abreviatura de la unidad de medida; donde la distancia está dada por:
d = |x2 - x1| La salida deberá ser como por ejemplo: 10 cm
9. Dado el valor del radio de una esfera y una cadena con la abreviatura de la unidad de
medida, calcular y desplegar el volumen de la esfera con sus unidades respectivas. La
salida deberá ser como por ejemplo: 3.14 cm^3
10. Dada la longitud del lado de un cubo y una cadena conteniendo la abreviatura de la
unidad de medida de dicha longitud, calcular y desplegar el volumen del cubo. La salida
deberá ser como por ejemplo: 8 mt^3
11. Diseñar una solución que realice y despliegue la suma aritmética de tres cantidades. Se
pide que se haga de la siguiente forma: se debe ingresar primero una cadena en la que
el usuario escribe el nombre de los “objetos” a sumar (por ejemplo: manzanas), luego
ingresa las tres cantidades, el programa las suma y reporta los resultados de la
siguiente manera: 20 manzanas
12. Diseñar una solución que realice la división aritmética. Se pide que se haga de la
siguiente forma: se ingresarán 2 cadenas, la primera corresponde a las unidades del
numerador y la segunda, son las unidades del denominador. Luego, se pedirán los
valores numerador y denominador, respectivamente. El resultado podría ilustrarse de la
siguiente manera: si ingresa “peras” y “niño”, y, luego ingresa 10 y 5, se mostrará como
salida: 2 peras por niño.

15
Anexo: Funciones Matemáticas en C#

Para utilizar en el diseño de una solución en C#, las funciones trigonométricas, logarítmicas y
otras funciones matemáticas comunes hay que agregar “using System;” al inicio del
programa y cada vez que se vaya a ocupar una función matemática se debe seguir la
siguiente sintaxis

Math.FUNCION A UTILIZAR

Teniendo en cuenta que la variable donde se almacenara el resultado de la función debe ser
del mismo tipo de dato que dicho resultado generado. Las funciones matemáticas se
describen a continuación.

Metodos

Devuelve el valor absoluto de un número Decimal.

Abs(Decimal)

Abs(Double) Devuelve el valor absoluto de un número de punto

flotante de precisión doble.

Abs(Int16) Devuelve el valor absoluto de un entero de 16 bits

con signo.

Abs(Int32) Devuelve el valor absoluto de un entero de 32 bits

con signo.

Abs(Int64) Devuelve el valor absoluto de un entero de 64 bits

con signo.

Abs(SByte) Devuelve el valor absoluto de un entero de 8 bits con

signo.

Abs(Single) Devuelve el valor absoluto de un número de punto

flotante de precisión sencilla.

Acos(Double) Devuelve el ángulo cuyo coseno es el número

especificado.

Asin(Double) Devuelve el ángulo cuyo seno es el número

especificado.

16
Atan(Double) Devuelve el ángulo cuya tangente corresponde al
número especificado.

Atan2(Double, Double) Devuelve el ángulo cuya tangente es el cociente de

dos números especificados.

BigMul(Int32, Int32) Calcula el producto completo de dos números de 32

bits.

Ceiling(Decimal) Devuelve el valor integral más pequeño que es mayor

o igual que el número decimal especificado.

Ceiling(Double) Devuelve el valor integral más pequeño que es mayor

o igual que el número de punto flotante de precisión
doble especificado.

Cos(Double) Devuelve el coseno del ángulo especificado.

Cosh(Double) Devuelve el coseno hiperbólico del ángulo

especificado.

DivRem(Int32, Int32, Int32) Calcula el cociente de dos números enteros de 32

bits con signo y devuelve también el resto de la
división como parámetro de salida.

DivRem(Int64, Int64, Int64) Calcula el cociente de dos números enteros de 64

bits con signo y devuelve también el resto de la
división como parámetro de salida.

Exp(Double) Devuelve e elevado a la potencia especificada.

Floor(Decimal) Devuelve el número entero más grande menor o igual

que el número decimal especificado.

Floor(Double) Devuelve el número entero más grande menor o igual

que el número de punto flotante de precisión doble
especificado.

IEEERemainder(Double, Double) Devuelve el resto de la división de dos números

especificados.

Log(Double) Devuelve el logaritmo natural (en base e) de un

número especificado.

Log(Double, Double) Devuelve el logaritmo de un número especificado en

una base determinada.

17
Log10(Double) Devuelve el logaritmo en base 10 de un número
especificado.

Max(Byte, Byte) Devuelve el mayor de dos enteros de 8 bits sin signo.

Max(Decimal, Decimal) Devuelve el mayor de dos números decimales.

Max(Double, Double) Devuelve el mayor de dos números de punto flotante

de precisión doble.

Max(Int16, Int16) Devuelve el mayor de dos enteros de 16 bits con

signo.

Max(Int32, Int32) Devuelve el mayor de dos enteros de 32 bits con

signo.

Max(Int64, Int64) Devuelve el mayor de dos enteros de 64 bits con

signo.

Max(SByte, SByte) Devuelve el mayor de dos enteros de 8 bits con

signo.

Max(Single, Single) Devuelve el mayor de dos números de punto flotante

de precisión sencilla.

Max(UInt16, UInt16) Devuelve el mayor de dos enteros de 16 bits sin

signo.

Max(UInt32, UInt32) Devuelve el mayor de dos enteros de 32 bits sin

signo.

Max(UInt64, UInt64) Devuelve el mayor de dos enteros de 64 bits sin

signo.

Min(Byte, Byte) Devuelve el menor de dos enteros de 8 bits sin signo.

Min(Decimal, Decimal) Devuelve el menor de dos números decimales.

Min(Double, Double) Devuelve el menor de dos números de punto flotante

de precisión doble.

Min(Int16, Int16) Devuelve el menor de dos enteros de 16 bits con

signo.

Min(Int32, Int32) Devuelve el menor de dos enteros de 32 bits con

signo.

18
Min(Int64, Int64) Devuelve el menor de dos enteros de 64 bits con
signo.

Min(SByte, SByte) Devuelve el menor de dos enteros de 8 bits con

signo.

Min(Single, Single) Devuelve el menor de dos números de punto flotante

de precisión sencilla.

Min(UInt16, UInt16) Devuelve el menor de dos enteros de 16 bits sin

signo.

Min(UInt32, UInt32) Devuelve el menor de dos enteros de 32 bits sin

signo.

Min(UInt64, UInt64) Devuelve el menor de dos enteros de 64 bits sin

signo.

Pow(Double, Double) Devuelve un número especificado elevado a la

potencia especificada.

Round(Decimal) Redondea un valor decimal al valor integral más

próximo.

Round(Decimal, Int32) Redondea un valor decimal al número especificado

de dígitos fraccionarios.

Round(Decimal, Int32, MidpointRounding) Redondea un valor decimal al número especificado

de dígitos fraccionarios.Un parámetro especifica el
redondeo del valor si está a la mitad del intervalo
entre dos números.

Round(Decimal, MidpointRounding) Redondea un valor decimal al entero más próximo.Un

parámetro especifica el redondeo del valor si está a
la mitad del intervalo entre dos números.

Round(Double) Redondea un valor de punto flotante de precisión

doble al valor integral más cercano.

Round(Double, Int32) Redondea un valor de punto flotante de precisión

doble al número especificado de dígitos fraccionarios.

Round(Double, Int32, MidpointRounding) Redondea un valor de punto flotante de precisión

doble al número especificado de dígitos fraccionarios.

Round(Double, MidpointRounding) Redondea un valor de punto flotante de precisión

19
 doble al entero más cercano.Un parámetro especifica
el redondeo del valor si está a la mitad del intervalo
entre dos números.

Sign(Decimal) Devuelve un valor que indica el signo de un número

decimal.

Sign(Double) Devuelve un valor que indica el signo de un número

de punto flotante de precisión doble.

Sign(Int16) Devuelve un valor que indica el signo de un entero de

16 bits con signo.

Sign(Int32) Devuelve un valor que indica el signo de un entero de

32 bits con signo.

Sign(Int64) Devuelve un valor que indica el signo de un entero de

64 bits con signo.

Sign(SByte) Devuelve un valor que indica el signo de un entero de

8 bits con signo.

Sign(Single) Devuelve un valor que indica el signo de un número

de punto flotante de precisión sencilla.

Sin(Double) Devuelve el seno del ángulo especificado.

Sinh(Double) Devuelve el seno hiperbólico del ángulo especificado.

Sqrt(Double) Devuelve la raíz cuadrada de un número

especificado.

Tan(Double) Devuelve la tangente del ángulo especificado.

Tanh(Double) Devuelve la tangente hiperbólica del ángulo

especificado.

Truncate(Decimal) Calcula la parte entera de un número decimal

especificado.

Truncate(Double) Calcula la parte entera de un número de punto

flotante de precisión doble especificado.

Para más información visitar: https://docs.microsoft.com/es-

es/dotnet/api/system.math?redirectedfrom=MSDN&view=netframework-4.7.2

20