INGENIERIA SISTEMAS COMPUTACIONALES

FUNDAMENTOS DE
ALGORITMOS
SEMANA 5
5
ING. Sly Stalim SANCHEZ SAAVEDRA
 LOGRO DE LA SESIÓN
Al termino de la sesión los estudiantes estarán en la condición
de:
❖Comprender e implementar funciones definidas de usuarios.
❖ Reconocer los tipos de funciones así como el uso de funciones con parámetros por
valor y referencia.
❖Utiliza variables Globales locales y estáticas demostrando lógica y habilidad en la
implementación de los algoritmos en el lenguaje de programación C#
TEMARIO

❖Funciones definidas por el usuario (Métodos)

❖Tipos de funciones (Return, void), Parámetros

❖Alcance de variables: Globales, locales, estáticas

❖Funciones: Parámetros por valor y por referencia

❖Funciones de encabezados propias (Bibliotecas)

FUNCIONES DEFINIDAS POR EL
USUARIO (MÉTODOS)
 Funciones definidas por el usuario

Introducción: Divide y vencerás

• Por ejemplo, en una fábrica de bombones donde existen

distintos departamentos: uno para hacer los bombones,
otro que pone los bombones en los envoltorios y el último,
los envuelve con detalles.

• Si la fábrica de bombones no estuviese dividida en

departamentos, sino que las distintas tareas estuviesen
entremezcladas, en el caso de que ocurriese un error sería
muy difícil determinar exactamente la causa.
 Funciones definidas por el usuario

Introducción: Divide y vencerás

• Pero con la fábrica dividida en tareas es muy

fácil localizar fallos, con comprobar el estado
en el que salen los bombones o los
envoltorios de sus respectivos departamentos
podemos saber en qué departamento está la
avería y resolver el problema.
Funciones definidas por el usuario

Ventajas de la programación modular

Las ventajas de la programación modular son:
❖ Nos permite descomponer el programa en subprogramas.
❖ Para comprobar un subprograma no es necesario tener que
probar el resto del programa.
❖ Los programas son más claros.
❖ Los programas se pueden crear entre varias personas: cada
persona puede crear un subprograma y posteriormente
juntarlos en un programa.
Funciones definidas por el usuario

Métodos en C#
Un método es un conjunto de instrucciones a las que se les da un
determinado nombre de tal manera que sea posible ejecutarlas en
cualquier momento sin tenerlas que reescribir sino usando solo su
nombre. A estas instrucciones se les denomina cuerpo del método,
y a su ejecución a través de su nombre se le denomina llamada al
método.
Los métodos, también llamados funciones, son trozos de código que
reciben datos, procesan los datos, y a veces devuelven algún valor.
 TIPOS DE FUNCIONES
(RETURN, VOID, PARÁMETROS)
 Tipos de métodos en C#

Tipos de retorno de un métodos en C#

Tipos de datos
❖Es el tipo de dato que devuelve los métodos en C#. El
tipo de dato de retorno podemos mencionar como: int, Numéricos Lógicos Texto
float, char, bool entre otros. Si la función no devuelve
nada se utiliza la palabra reservada void.
Enteros Caracteres

❖A partir de C# 7.0, C# admite funciones locales. Las Reales Cadenas

funciones locales son métodos privados de un tipo que
están anidados en otro miembro. Solo se pueden
llamar desde su miembro contenedor.
 Tipos de métodos en C#

ESTRUCTURA DE UN METODO
<modificador> tipoDato nombreFuncion(<argumentos>)
{
... instrucciones ...
}

❖ public, todo el programa y otro externo tendrán acceso a la Procedimiento limpiar

función.
❖ private, solamente el código de la misma class o struct puede private void limpiar()
acceder al tipo o miembro. {
❖ protected, solamente el código de la misma class, o bien de txtNumero1.Clear();
una class derivada de esa class, puede acceder al tipo o txtNumero2.Clear();
miembro. txtResultado.Clear();
❖ static, permite acceder a las variables y métodos aunque no }
tengamos una instancia del objeto que los contiene.
Funciones definidas por el usuario

ESTRUCTURA DE UN METODO
<ambito> tipoDato nombreFuncion(<argumentos>)
{
... instrucciones ...
}

❖ public, todo el programa y otro externo tendrán acceso a la

función.
❖ private, solamente el código de la misma class o struct puede Función SUMAR
acceder al tipo o miembro.
❖ protected, solamente el código de la misma class, o bien de private int sumar(int num1, int num2)
una class derivada de esa class, puede acceder al tipo o {
miembro. int resultado = num1 + num2;
❖ static, permite acceder a las variables y métodos aunque no return resultado;
tengamos una instancia del objeto que los contiene. }
Tipos de métodos en C#

static void bienvenida()

{
Console.WriteLine("Hola UPN");
}

static string saludo(string nombre)

{
String str = String.Concat("Hola: ", nombre);
return str;
}

static int suma(int a, int b)

{
return (a + b);
}

static double division(ref double num, double den)

{
double res = num / den;
num++;
return res;
}
Tipos de métodos en C#

Definición de métodos en C#
<ambito> <static> <tipoRetorno> <nombreMetodo> (<parámetros>)
{
<cuerpo>
}

En <ambito> en valor por default es public, los otros valores son: private y protected.
En <static> es opcional.
En <tipoRetorno> se indica cual es el tipo de dato que va a devolver (int, double, char, string, etc.), y si no devuelve
ninguno se ha de escribir void en su lugar.
Es posible que un método no tomen parámetros, si un método los toma se ha de indicar en <parámetros> cual es
el nombre y tipo de cada uno de ellos, separándolos con coma si son mas de uno.
El <cuerpo> del método también es opcional, pero si el método retorna algún tipo de dato entonces ha de incluir
una instrucción return que indica cual es el dato a devolver.
 Tipos de métodos en C#

Invocación de métodos en C# <tipo>.<nombreMetodo> (<valoresParámetros>)

❖La forma en que se puede llamar a un método del que
public static void Main(string[] args)
se trate. Si es un método de tipo (método estático), {
Program.bienvenida();
entonces se ha de usar: Console.ReadKey();
}
❖ En <tipo> ha de indicarse el tipo donde se haya definido el
método o algún subtipo suyo.
<nombreMetodo> (<valoresParámetros>)

❖Sin embargo, si el método pertenece al mismo tipo que public static void Main(string[] args)
{
el código que lo llama entonces se puede usar la bienvenida();
Console.ReadKey();
notación abreviada: }
Estructura básica de un programa en C# usando métodos

using System;
public static void Main(string[] args)
namespace Metodos {
{ int s ;
class Program double div, n = 3, d = 2;
{ string msg = "";
public static void bienvenida()
{ Program.bienvenida();
Console.WriteLine("Hola UPN"); msg = saludo("César Edinson");
} Console.WriteLine(msg);

public static string saludo(string nombre) s = suma(5, 10);

{ Console.WriteLine("La suma es: {0}",s);
String str = String.Concat("Hola: ", nombre);
return str; div = division(ref n, d);
} Console.WriteLine("La division es: {0}", div);
Console.WriteLine("EL nuevo valor de (n) es: {0}", n);
public static int suma(int a, int b)
{ Console.ReadKey();
return (a + b); }
} }
}
public static double division(ref double num, double den)
{
double res = num / den;
num++;
return res;
}
Ejemplo 1

Crear un programa en C# e implementar los

siguientes métodos vacíos:
• bienvenido(), el método deberá imprimir el siguiente
mensaje “Bienvenidos alumnos a la UPN”.
• saludar(), el método deberá solicitar el nombre del
alumno e imprimir el siguiente mensaje: “Bienvenido:
” + nom_alum.
• despedida(), el método deberá imprimir el siguiente
mensaje “Regresaremos muy pronto”.
Ejemplo 1

using System; static void Main(string[] args)

{
namespace Ejemplo1 bienvenido();
{ saludar();
class Program despedida();
{ Console.ReadKey();
}
static void bienvenido() }
{ }
Console.WriteLine("Bienvenidos alumnos a la UPN");
}

static void saludar()

{
string nombre;
Console.Write("Ingresar tu nombre: ");
nombre = Console.ReadLine();
Console.WriteLine("Bienvenido: " + nombre);
}

static void despedida()

{
Console.WriteLine("Regresaremos muy pronto");
}
Ejemplo 2

Crear un programa en C# e implementar

un método que retorne la potencia() de
un numero natural, el numero y el
exponente serán ingresados por teclado
y serán enviados al método como
parámetros.
Ejemplo 2

using System; static void Main(string[] args)

{
namespace Ejemplo2
{ int n, e, r;
class Program Console.Write("Ingresar numero: ");
{ n = int.Parse(Console.ReadLine());

static int exponente(int n, int expo) Console.Write("Ingresar exponente: ");

{ e = int.Parse(Console.ReadLine());
int f = 1;
if (expo == 0) { r = exponente(n, e);
return 1;
} Console.Write("Resultado = {0}", r);
else Console.ReadKey();
{ }
for (int i = 1; i <= expo; i++) }
{ }
f = f * n;
}
return f;
}
}
Ejemplo 3

Crear un programa en C# e implementar un método que retorne el

factorial() de un número natural entero, el numero será ingresado por
teclado y será enviado al método como parámetro.
Ejemplo 3

using System;

namespace Ejemplo3
{
class Program
{
static int factorial(int n)
{
int f = 1;
for (int i = 1; i <= n; i++)
{
f = f * i;
}
return f;
}

static void Main(string[] args)

{
int n, f;
Console.Write("Ingresar numero: ");
n = int.Parse(Console.ReadLine());
f = factorial(n);

Console.Write("El factorial {0}! es: {1}", n, f);

Console.ReadKey();
}
}
}
Ejemplo 4

Crear un programa en C# e implementar los siguientes

métodos:
El método que retorne el mayor() de 3 números.
El método que retorne el menor() de 3 números.
El método que retorne el numero intermedio() de 3 números.
Los 3 números serán ingresados por teclados y enviados como
parámetros a las funciones mencionadas anteriormente.
Ejemplo 4

using System; static int buscarMenor(int a, int b, int c)

{
namespace Ejemplo4
{ int menor;
class Program if (a <= b && a <= c)
{ {
menor = a;
static int buscarMayor(int a, int b, int c) }
{ else
int mayor; {
if (a > b && a > c) if (b < c)
{ {
mayor = a; menor = b;
} }
else else
{ {
if (b > c) menor = c;
{ }
mayor = b; }
} return menor;
else }
{
mayor = c;
}
}
return mayor;
}
Ejemplo 4

static int buscarIntermedio(int a, int b, int c, int mayor, Console.WriteLine("El mayor es = {0}", mayor);
int menor) Console.WriteLine("El menor es = {0}", menor);
{ Console.WriteLine("El intermedio es = {0}", inter);
Console.ReadKey();
int inter; }
inter = (a + b + c) - (mayor + menor); }
return inter; }
}

static void Main(string[] args)

{

int a, b, c, mayor, menor, inter;

Console.Write("Ingresar numero 1: ");
a = int.Parse(Console.ReadLine());

Console.Write("Ingresar numero 2: ");

b = int.Parse(Console.ReadLine());

Console.Write("Ingresar numero 3: ");

c = int.Parse(Console.ReadLine());

mayor = buscarMayor(a, b, c);

menor = buscarMenor(a, b, c);
inter = buscarIntermedio(a, b, c, mayor, menor);
Ejemplo 5

Crear un programa en C# que

implemente los métodos potencia() y
factorial(), para calcular la siguiente
serie. El termino n es ingresado por
teclado.
11 22 33 44 𝑛𝑛
𝑆= + + + + …+
1! 2! 3! 4! 𝑛!
Ejemplo 5

using System;
namespace Ejemplo5 static void Main(string[] args)
{ {
class Program
{ int lim;
static int factorial(int n) double s = 0;
{
int f = 1; Console.Write("Ingresar limite: ");
for (int i = 1; i <= n; i++) lim = int.Parse(Console.ReadLine());
{
f = f * i; for (int i = 1; i <= lim; i++)
} {
return f; double e = (double)exponente(i, i);
} double f = (double)factorial(i);
static int exponente(int n, int expo) s = s + e / f;
{ }
int f = 1;
if (expo == 0) Console.Write("S = {0}", s);
return 1; Console.ReadKey();
else }
{ }
for (int i = 1; i <= expo; i++) }
{
f = f * n;
}
return f;
}
}
ALCANCE DE VARIABLES
Alcance de variables

Ámbito de variables using System;

namespace Ejemplo6
Variables locales {
class Program
Es aquella que sólo es utilizable dentro del código de la función. {
// variable global
Variables globales static int n1 = 10;

Es aquella cuyo ámbito es todo el programa, incluso dentro de una static void Main(string[] args)
{
función. //variable local
int a = 5;
}
}
}
Ejemplo 6

Crear un programa en C# que

implemente los métodos ingresar() 2
números naturales, sumar() 2 números
naturales e imprimir() el resultado, los
2 números serán declarados como
variables globales y luego ser
ingresados por teclado.
Ejemplo 6

using System;
static void imprimir()
namespace Ejemplo6 {
{ Console.WriteLine("La suma es: {0}", s);
class Program }
{
static void Main(string[] args)
// variable global {
static int n1, n2, s; ingreso();
sumar();
static void ingreso() imprimir();
{ Console.ReadKey();
Console.Write("Ingresar N1: "); }
n1 = int.Parse(Console.ReadLine()); }
Console.Write("Ingresar N2: "); }
n2 = int.Parse(Console.ReadLine());
}

static void sumar()

{
s = n1 + n2;
}
PARÁMETROS POR VALOR Y POR
REFERENCIA
Parámetros por valor y por referencia

Paso por valor y paso por referencia

Paso por valor:
La información de la variable se almacenan en una dirección de
memoria diferente al recibirla en la función, por lo tanto si el
valor de esa variable cambia no afecta la variable original, solo se
modifica dentro del contexto de la función.
Paso por referencia:
La variable que se recibe como parámetro en la función, apunta
exactamente a la misma dirección de memoria que la variable
original por lo que si dentro de la función se modifica su valor
también se modifica la variable original.
 Ejemplo 7

Crear un programa en C# que implemente los siguientes

métodos:
incremento1(int n1) con un paramento entero con
paso por valor, dentro del cuerpo de la función la variable
n1 se debe incrementar en 10
incremento2(ref int n1) con un paramento entero
con paso por referencia, dentro del cuerpo de la función la
variable n1 se debe incrementar en 10.
En la función principal main() se deben crear 2 variables
enteras a = 10 y b = 10 y posteriormente invocar a ambas
funciones e imprimir posteriormente las variables.
Ejemplo 7

using System;

namespace Ejemplo7
{
class Program
{
static void incremento1(int n1)
{
n1 = n1 + 10;
}

static void incremento2(ref int n1)

{
n1 = n1 + 10;
}

static void Main(string[] args)

{
int a = 10, b = 10;

incremento1(a);
Console.WriteLine("a = {0}", a);
incremento2(ref b);
Console.WriteLine("b = {0}", b);
Console.ReadKey();
}
}
}
FUNCIONES DE ENCABEZADO
PROPIAS
Funciones de encabezados propias.

¿Qué se entiende por funciones de encabezado?

Se conoce como librerías (o bibliotecas) a cierto tipo de archivos que

podemos importar o incluir en nuestro programa.
Estos archivos contienen las especificaciones de diferentes funcionalidades
ya construidas y utilizables que podremos agregar a nuestro programa, como
por ejemplo leer del teclado o mostrar algo por pantalla entre muchas otras
más.
Funciones de encabezados propias.

Bibliotecas o librerías en C#

Las librerías en C# permiten hacer nuestros

programas más modulares "reutilizables"
facilitando además crear programas con
funcionalidades bastante complejas en unas
pocas líneas de código.
Ejemplo 1

Crear una biblioteca propia de

usuario llamado Libreria.cs, en la
cual implementara las siguientes
funciones saludoInicio(),
saludoFin() y sumar2Numeros(int a,
int b).
 Hacer clic derecho con el mouse

Ejemplo 1
Ejemplo 1
Seleccionamos la opción Clase y a la
clase seleccionada le asignamos el
nombre Libreria.cs
using System;

Ejemplo 1
namespace Ejemplo1
{
class Libreria
{
static public void saludoInicio()
{
Console.WriteLine("*************************");
Console.WriteLine(" Inicio del Programa ");
Console.WriteLine("*************************");
}

static public void saludoFin()

{
Console.WriteLine("*************************");
Console.WriteLine(" Fin del Programa ");
Console.WriteLine("*************************");
}

static public int sumar2Numeros(int a, int b)

{
return (a + b);
}

}
}

Libreria.cs
 using System;

Ejemplo 1
namespace Ejemplo1
{
class Program
{
static void Main(string[] args)
{
int n1, n2, s;

Libreria.saludoInicio();

Console.Write("Ingresar num. 1: ");

n1 = int.Parse(Console.ReadLine());
Console.Write("Ingresar num. 2: ");
n2 = int.Parse(Console.ReadLine());

s = Libreria.sumar2Numeros(n1, n2);
Console.WriteLine("La suma es: {0}",s);

Libreria.saludoFin();
Console.ReadKey();
}
}
}

Program.cs
Ejemplo 2

Crear una biblioteca propia de

usuario llamado Calculos.cs, en la
cual implementara las siguientes
funciones int potenciaNat(int b, int
e), int factorialNat(int n), y calcular la
siguiente serie.
11 22 33 𝑛𝑛
𝑆= + + +⋯ +
1! 2! 3! 𝑛!
Ejemplo 2

using System;

namespace Ejemplo2
{
class Calculos
{
static public int potenciaNat(int b, int e)
{
int f = 1;
for (int i = 1; i <= e; i++)
{
f = f * b;
}
return f;
}

static public int factorialNat(int n)

{
int f = 1;
for (int i = 1; i <= n; i++)
{
f = f * i;
}
return f;
}
}
}
Calculos.cs
ING. CÉSAR EDINSON AGUIRRE RODRÍGUEZ
 Ejemplo 2

using System;

namespace Ejemplo2
{
class Program
{
static void Main(string[] args)
{
int n;
double s = 0;
Console.Write("Ingresar limite (n): ");
n = int.Parse(Console.ReadLine());

for (int i = 1; i <= n; i++)

{
int p = Calculos.potenciaNat(i, i);
int f = Calculos.factorialNat(i);
s = s + (double)p / (double)f;
}

Console.WriteLine("S = {0}", s);

Console.ReadKey();
}
}
}
Program.cs
 Ejemplo 3

Crear una biblioteca propia de usuario llamado Series.cs, en la

cual se implementara las siguientes funciones int numNprimo
(int n), int numNFibo(int n), int potenciaNat(int b, int e)
, y calcular la siguiente serie.

00 11 11 22 33 𝑛𝑛
𝑆 = 2 + 3 + 5 + 7 + 11 + ⋯ + 𝑛
2 3 5 7 11 𝑛
 Ejemplo 3

using System;
static public int numNFibo(int lim)
namespace Ejemplo3 {
{ int n, x = 0, y = 1, z, nfibo = 0;
class Series for (int i = 1; i <= lim; i++)
{ {
static public int numNprimo(int lim) if (i == 1)
{ {
int k = 1, cont, nPrimo = 0; nfibo = x;
for (int i = 2; k <= lim; i++) }
{ else if (i == 2)
cont = 0; {
for (int j = 1; j <= i; j++) nfibo = y;
{ }
if (i % j == 0) else
{ {
cont++; z = x + y;
} nfibo = z;
} x = y;
if (cont == 2) y = z;
{ }
nPrimo = i; }
k++; return nfibo;
} }
} }
return nPrimo; }
}
Series.cs
 Ejemplo 3

using System;

namespace Ejemplo3
{
class Program
{
static void Main(string[] args)
{
int n;
double s = 0;
Console.Write("Ingresar limite (n): ");
n = int.Parse(Console.ReadLine());

for (int i = 1; i <= n; i++)

{
int fib = Series.numNFibo(i);
int pri = Series.numNprimo(i);
s = s + (double) fib / (double) pri;
}
Console.WriteLine("S = {0}", s);
Console.ReadKey();
}
}
}

Program.cs
¿Preguntas o comentarios?
 Bibliografía

• Ferguson, J., Patterson, B. and Beres, J., 2003. La Biblia De C#. 1st ed. Madrid: Grupo Anaya S.A.

• Bell, D., 2020. C# Para Estudiantes. 1st ed. México: PEARSON EDUCACIÓN,.

• Cosio, L. and Arrioja, N., 2010. C#. 1st ed. Buenos Aires: Manual Users.

• Ruiz García, J., 2020. Libro C# Yellow Book. [online] Jesús Ruiz García – Blog. Available at:
<https://jesusruizgarcia.wordpress.com/2018/05/30/libro-c-yellow-book-2016-edicion-8-2-en-espanol/>

• Tutoriales Ya. 2020. C# Ya. [online] Available at: <https://www.tutorialesprogramacionya.com/csharpya/>