Ejercicios 03 PDF

HERRAMIENTAS DE DESARROLLO DE SOFTWARE
Contenido
Introducción a Visual Studio 2013 ........................................................................................7
Algoritmos en C# ...............................................................................................................7
Algoritmos en C# ......................................................................................................................7
Qué es un programa? ...........................................................................................................7
Algoritmo .............................................................................................................................7
Diagrama de flujo .................................................................................................................7
Lenguaje de Programación ...................................................................................................8
Pseudocódigo .......................................................................................................................9
Matrices en C# .................................................................................................................10
Matrices en C# .......................................................................................................................10
Declaración de una Matriz en C# ......................................................................................11
Ejercicios Resueltos de Matrices en C# ..............................................................................12
Ejemplo Básico en C# ..................................................................................................14
Ejemplo Básico en C# ..........................................................................................................14
Comentarios en C# ...........................................................................................................15
Método Principal ..............................................................................................................15
Crear un Proyecto en C# .............................................................................................16
Codificación del problema con el lenguaje C#. ..............................................................17
Consideraciones a tener en cuenta en cada proyecto. ....................................................17
Pasos a Seguir para crear un proyecto en C# .................................................................17
Ejercicios Resueltos de Estructura Secuencial en C# .........................................19
Ejercicios Resueltos de Estructura Secuencial en C# ........................................................19
Estructura Secuencial en C# ......................................................................................23
Estructura Secuencial en C#................................................................................................23
Ejercicios Resueltos de Estructura Secuencial en C# ....................................................23
Estructuras Condicionales en C# ..............................................................................24
Estructuras Condicionales en C# ........................................................................................24
Estructura Condicional if - else en c# .............................................................................25
Estructura condicional simple. ........................................................................................25
Ejemplos de Estructura Secuencial en c# ...............................................................26
Ejemplos de Estructura Secuencial en c# ...........................................................................26
Operadores Aritméticos en C# ......................................................................................28
Operadores Aritméticos en C# ...............................................................................................28
ING. VLADIMIR FLOREZ TINTA 1

Ejercicios Resueltos de Estructura Condicional Compuesta ...............................................29

Ejercicios Resueltos de Estructura Condicional en C# ..............................................30
Ejercicios Resueltos de Estructura Condicional en C# ............................................................30
Ejemplo de Promedio de Notas en C# .........................................................................32
Ejemplos de If - Else en C# ............................................................................................34
Ejemplos de If - Else en C# ......................................................................................................34
Ejercicios Resueltos de Estructura Condicional Anidada en C# ...............................37
Ejercicios Resueltos de Estructura condicional anidad en c# .............................................37
Estructura Condicional Anidada en C# .........................................................................40
Estructura Condicional Anidada en C# ...................................................................................40
Ejercicios Resueltos de Estructura condicional anidada en c#............................................41
Estructura condicional compuesto en c# ......................................................................43
Estructura condicional compuesto en c# ...............................................................................43
Operador || en C# ..............................................................................................................43
operador && en C# ............................................................................................................43
Operador ? en C# ...............................................................................................................43
Ejemplos de Estructura Anidadas en C# ......................................................................44
Ejemplos de Estructura Anidadas en C# .................................................................................44
Ejercicios Resueltos de Estructura While en C# .........................................................47
Ejercicios Resueltos de Estructura While en C# ......................................................................47
Estructura Repetitiva While en C# ................................................................................50
Estructura Repetitiva While en C# ..........................................................................................50
Ejemplos de Estructura While en C# ............................................................................51
Ejemplos de Estructura While en C# ......................................................................................51
Problemas de Estructura While en C# ..........................................................................53
Problemas de Estructura While en C# ....................................................................................53
Estructura repetitiva For en C# ......................................................................................56
Estructura repetitiva For en C# ..............................................................................................56
Factorial de un Numero en C# .......................................................................................58
Ejemplos del Bucle For en C# .......................................................................................59
Ejemplos del Bucle For en C# .................................................................................................59
Ejercicios Resueltos de Estructura Repetitiva For en C# ..........................................62
Ejercicios Resueltos de Estructura Repetitiva For en C# .........................................................62
Estructura repetitiva Do While en C# ............................................................................65
Estructura repetitiva Do While en C# .....................................................................................65

Do en C# .............................................................................................................................65
Tabla de Multiplicar en C# ..............................................................................................66
Tabla de Multiplicar en C# ......................................................................................................66
Ejemplo de Do While en C# ...........................................................................................67
Ejemplo de Do While en C# ....................................................................................................67
Ejercicios de la Estructura Do While en C# .................................................................69
Ejercicios Resueltos de Estructura Repetitiva Do While en C# ...............................................69
Ejercicios con Cadena de Caracteres en C# ...............................................................71
Ejercicios con Cadena de Caracteres en C# ............................................................................71
Cadena de Caracteres en C# ........................................................................................73
Cadena de Caracteres en C# ...................................................................................................73
Ejercicios Resueltos de Cadena de Caracteres en C# ..........................................................75
Ejercicios Resueltos de Clases en C# ..........................................................................76
Ejercicios Resueltos de Clases en C# ......................................................................................76
Clases en C# ....................................................................................................................81
Clase en C# .............................................................................................................................81
Definición de un Método en C# ..............................................................................................82
Estructura de una Clase en C# ................................................................................................82
Objetos en C# ..................................................................................................................82
Declaración de Objetos en C# ................................................................................................82
Declaración de una clase y un Objeto ....................................................................................82
Declaración de varios Objetos dentro de un Clase .................................................................83
Ejemplos de Clases en C# .............................................................................................85
Ejemplos de Clases en C# .......................................................................................................85
Arreglos en C# .................................................................................................................89
Arreglos en C# ........................................................................................................................89
Como Declarar e Inicializar un Arreglo en C# .........................................................................89
Declaración de un Arreglo de tipo Vector en C# ....................................................................89
Ejercicios con Objetos en C# .........................................................................................90
Ejercicios Resueltos de Objetos en C# ....................................................................................90
Ejercicios Resueltos de Arreglos en C# .......................................................................94
Ejercicios Resueltos de Arreglos en C# ...................................................................................94
Arreglos Multi-dimensionales en C# .............................................................................98
Arreglos Multi-dimensionales ................................................................................................98
Ejercicios de Arreglos Multi-dimensionales en C# ......................................................99

Ejercicios de Arreglos Multi-dimensionales en C# ..................................................................99

Ejercicios Resueltos de Vectores en C# ....................................................................101
Ejercicios Resueltos de Vectores en C# ................................................................................101
Suma de vectores en C# ..............................................................................................103
Suma de vectores en C# .......................................................................................................103
Ejercicios con Vectores en C# .....................................................................................106
Ejercicios con Vectores en C# ...............................................................................................106
Matrices en C#..............................................................................................................111
Matrices en C# ....................................................................................................................111
Declaración de Matrices en C# ......................................................................................111
Resta de Vectores en C# ...........................................................................................112
Resta de Vectores en C# .....................................................................................................112
Ejemplo de Matrices en C# ..........................................................................................113
Ejemplo de Matrices en C# ...................................................................................................113
Ejercicios Resueltos de Matrices en C# .....................................................................115
Ejercicios Resueltos de Matrices en C# ................................................................................116
Vectores y Matrices en C#.........................................................................................119
Vectores y Matrices en C# .................................................................................................119
Vectores en C# ....................................................................................................................120
Matrices en C# ....................................................................................................................120
Suma de Matrices en C# ............................................................................................120
Suma de Matrices en C# ....................................................................................................120
Ejemplo de Vectores y Matrices en C#...................................................................122
Ejemplo de Vectores y Matrices en C# .............................................................................122
Ejercicios De Vectores y Matrices en C# ...............................................................124
Ejercicios De Vectores y Matrices en C# ..........................................................................124
Ordenamiento por Inserción Directa en C# ...............................................................126
Método de Ordenamiento por Inserción directa en C# .......................................................126
Métodos de Ordenamiento en C# ...............................................................................129
Métodos de Ordenamiento en C# ........................................................................................129
Ejemplo ............................................................................................................................129
Ordenamiento por Shell Sort en C# ............................................................................131
Método de Ordenamiento Shell Sort en C# .....................................................................131
Ordenamiento por Inserción Binaria en C# ................................................................133
Método de Ordenamiento por Inserción Binaria en C# .......................................................134

Ordenamiento por Burbuja en C# ...............................................................................135

Método de Ordenamiento Burbuja en C# ............................................................................135
Ordenamiento por Quick Sort en C# ...........................................................................137
Método de Ordenamiento Quick Sort en C# ........................................................................137
Ordenamiento por Merge Sort en C#..........................................................................139
Método de Ordenamiento Merge Sort en C# ......................................................................140
Ordenamiento por Shaker Sort en C# ........................................................................143
Método de Ordenamiento Shaker Sort en C# ......................................................................143
Ejercicios Resueltos de Arrays en C# ........................................................................144
Ejercicios Resueltos de Arrays en C# ....................................................................................144
Ordenar Vectores en C# ...............................................................................................149
Ordenar Vectores en C# .......................................................................................................149
Ejercicios de Ordenamiento en C# .......................................................................................149
Método de Ordenamiento de Inserción Binaria en C# .............................................151
Método de Ordenamiento de Inserción Binaria en C# .........................................................151
Ejemplo del Código Implementado ..................................................................................153
Un ejemplo de método de inserción binaria en C# ..........................................................154
Método de Ordenamiento de Inserción Directa en C# .............................................155
Método de Ordenamiento de Inserción Directa en C# .........................................................155
Ejemplo del Método de Ordenamiento Inserción Directa en c# .....................................156
Método de Ordenamiento Quick Sort en C# .........................................................158
Método de Ordenamiento Quick Sort en C# ....................................................................159
Ejemplo del Método de Ordenamiento Quick Sort en C# ...........................................161
Método de Ordenamiento Shell Sort en C# ...........................................................163
Ejemplo del Método de Ordenamiento Shell Sort en C# .............................................165
Método de Ordenamiento Merge Sort en C#.........................................................166
Método de Ordenamiento Merge Sort en C# ...................................................................166
Estrategia de Merge Sort ...................................................................................................167
Pseudocódigo del Método de Ordenamiento Merge Sort ................................................167
Ejemplo del Método de Ordenamiento Merge Sort en C# ..............................................168
Método de Ordenamiento Burbuja en C# ..............................................................170
Método de Ordenamiento Burbuja en C# ........................................................................170
Ejemplo del Método de Ordenamiento Burbuja en C# ...............................................172
Ejercicios Resueltos de Matrices en C# .....................................................................174
Ejercicios Resueltos de Matrices en C# ................................................................................174

Matrices en C Sharp......................................................................................................178
Declaración de una Matriz en C# .........................................................................................179
Constructores en C# .....................................................................................................180
Constructores en C# .............................................................................................................180
Búsqueda Binaria en C# ...............................................................................................182
Búsqueda Binaria en C# ........................................................................................................182
Búsqueda Binaria en C# ....................................................................................................183
Ejercicios con Clases en C# ........................................................................................186
Ejercicios con Clases en C# ...................................................................................................186
Ejercicios Resueltos de Constructores en C# ...........................................................189
Ejercicios Resueltos de Constructores en C# ........................................................................189

Introducción a Visual Studio 2013

Visual Studio es un conjunto completo de herramientas de desarrollo para la
generación de aplicaciones web ASP.NET, Servicios Web XML, aplicaciones de
escritorio y aplicaciones móviles. Visual Basic, Visual C#y Visual C++ utilizan
todos el mismo entorno de desarrollo integrado (IDE), que habilita el uso
compartido de herramientas y hace más sencilla la creación de soluciones en varios
lenguajes. Asimismo, dichos lenguajes utilizan las funciones de .NET Framework,
las cuales ofrecen acceso a tecnologías clave para simplificar el desarrollo de
aplicaciones web ASP y Servicios Web XML.
Algoritmos en C#
Algoritmos en C#
Qué es un programa?
Programa: Conjunto de instrucciones que entiende un ordenador para realizar
una actividad.
Todo programa tiene un objetivo bien definido: un procesador de texto es un
programa que permite cargar, modificar e imprimir textos, un programa de
ajedrez permite jugar al ajedrez contra el ordenador u otro contrincante humano.
La actividad fundamental del programador es resolver problemas empleando el
ordenador como herramienta fundamental.
Para la resolución de un problema hay que plantear un algoritmo.
Algoritmo
un algoritmo, es un conjunto preescrito de instrucciones o reglas bien definidas,
ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos
que no generen dudas a quien deba realizar dicha actividad. Dados un estado
inicial y una entrada, siguiendo los pasos sucesivos se llega a un estado final y se
obtiene una solución. Los algoritmos son el objeto de estudio de la algoritmia.
Diagrama de flujo
Un diagrama de flujo es la representación gráfica de un ALGORITMO.
Los símbolos gráficos a utilizar para el planteo de diagramas de flujo son:

Estos son los elementos esenciales que intervienen en el desarrollo de un

diagrama de flujo.
Lenguaje de Programación
Un lenguaje de programación es un idioma artificial diseñado para expresar
procesos que pueden ser llevados a cabo por máquinas como las computadoras.
Pueden usarse para crear programas que controlen el comportamiento físico y
lógico de una máquina, para expresar algoritmos con precisión, o como modo de
comunicación humana.1
Está formado por un conjunto de símbolos y reglas sintácticas y semánticas que
definen su estructura y el significado de sus elementos y expresiones. Al proceso
por el cual se escribe, se prueba, se depura, se compila (de ser necesario) y se
mantiene el código fuente de un programa informático se le llama programación.
También la palabra programación se define como el proceso de creación de un
programa de computadora, mediante la aplicación de procedimientos lógicos, a
través de los siguientes pasos:
El desarrollo lógico del programa para resolver un problema en particular.

Escritura de la lógica del programa empleando un lenguaje de programación

específico (codificación del programa).
Ensamblaje o compilación del programa hasta convertirlo en lenguaje de
máquina.
Prueba y depuración del programa.
Desarrollo de la documentación.
Pseudocódigo
En ciencias de la computación, y análisis numérico el pseudocódigo (o falso
lenguaje) es una descripción informal1 de alto nivel de un algoritmo informático
de programación, compacto e informal, que utiliza las convenciones estructurales
de un lenguaje de programación verdadero2 , pero que está diseñado para la
lectura humana en lugar de la lectura mediante máquina, y con independencia
de cualquier otro lenguaje de programación. Normalmente, el pseudocódigo
omite detalles que no son esenciales para la comprensión humana del algoritmo,
tales como declaraciones de variables, código específico del sistema y algunas
subrutinas. El lenguaje de programación se complementa, donde sea
conveniente, con descripciones detalladas en lenguaje natural, o con notación
matemática compacta. Se utiliza pseudocódigo pues este es más fácil de entender
para las personas que el código de lenguaje de programación convencional, ya
que es una descripción eficiente y con un entorno independiente de los principios
fundamentales de un algoritmo. Se utiliza comúnmente en los libros de texto y
publicaciones científicas que se documentan varios algoritmos, y también en la
planificación del desarrollo de programas informáticos, para esbozar la estructura
del programa antes de realizar la efectiva codificación. No existe una sintaxis
estándar para el pseudocódigo, aunque los ocho IDE's que manejan
pseudocódigo tengan su sintaxis propia. Aunque sea parecido, el pseudocódigo
no debe confundirse con los programas esqueleto que incluyen código ficticio,
que pueden ser compilados sin errores. Los diagramas de flujo y UML pueden ser
considerados como una alternativa gráfica al pseudocódigo, aunque sean más
amplios en papel.

Publicado por Yhonatan Robles Vega 2 comentarios:

Etiquetas: algoritmo, C#, c# paso a paso, c# ya, ejemplos c#, Ejercicios C#, introduccion a c#
Matrices en C#
Matrices en C#
Una matriz es una estructura de datos que permite almacenar un conjunto de datos
del mismo tipo.
Con un único nombre se define la matriz y por medio de DOS sub índices hacemos
referencia a cada elemento de la misma (componente)

Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada
elemento debemos indicar primero la fila y luego la columna, por ejemplo en la
componente 1,4 se almacena el valor 97.
En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz

deben ser del mismo tipo (int, float, string etc.)
Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores.
Declaración de una Matriz en C#

 Matrices multidimensionales:
 Matrices de matrices (escalonadas):
 Matrices multidimensionales:
 Matrices de matrices (escalonadas):
Matrices unidimensionales:
int[] numbers;
string[,] names;
byte[][] scores;
La declaración de matrices (como se muestra arriba) no crea realmente las

matrices. En C#, las matrices son objetos (se explica más adelante en este tutorial)
cuyas instancias deben crearse. Los siguientes ejemplos muestran cómo crear
matrices:
int[] numbers = new int[5];
string[,] names = new string[5,4];
byte[][] scores = new byte[5][];

for (int x = 0; x < scores.Length; x++)
{

scores[x] = new byte[4];

}
También se pueden utilizar matrices más grandes. Por ejemplo, se puede utilizar
una matriz rectangular de tres dimensiones:
int[,,] buttons = new int[4,5,3];
Incluso, se pueden combinar matrices rectangulares y escalonadas. Por ejemplo, el

siguiente código declara una matriz unidimensional que contiene matrices
tridimensionales de matrices bidimensionales de tipo int:
int[][,,][,] numbers;
Ejercicios Resueltos de Matrices en C#
Crear una matriz de 3 filas por 4 columnas con elementos de tipo int, ingresar sus
posiciones y luego imprimirlas.
C# admite matrices de una dimensión, matrices multidimensionales (matrices
rectangulares) y matrices de matrices (matrices escalonadas). El siguiente ejemplo
muestra cómo declarar diferentes tipos de matrices:
Ejemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Matriz
class Matriz
private int[,] mat;
public void Ingresar()
mat = new int[3, 4];
for (int f = 0; f < 3; f++)
for (int c = 0; c < 4; c++)
Console.Write("Ingrese posicion ["+(f+1)+","+(c+1)+"]: ");
string linea;
linea = Console.ReadLine();
mat[f, c] = int.Parse(linea);
public void Imprimir()
for (int f = 0; f < 3; f++)
for (int c = 0; c < 4; c++)
Console.Write(mat[f, c] + " ");

Console.WriteLine();
Console.ReadKey();
static void Main(string[] args)
Matriz ma = new Matriz();
ma.Ingresar();
ma.Imprimir();
Al ejecutar el código muestra el siguiente resultado:
Ejemplo Básico en C#
Ejemplo Básico en C#
El procedimiento siguiente crea una versión de C# del programa tradicional de
“Hola Mundo”. El programa muestra la cadena Hola Mundo!

El siguiente ejercicio muestra la solución del ejercicio "Hola Mundo!"
using System;
using System.Linq;
using System.Text;
namespace Primer_Proyecto
{
class Program
{
{
Console.WriteLine("Hola Mundo!");
// continuar al presonar una tecla
Console.WriteLine("Presione Enter para salir");
Console.ReadKey();
}
}
}
Elija la tecla F5 para ejecutar el proyecto. Aparecerá una ventana del símbolo del
sistema con la línea Hola Mundo!
Comentarios en C#
La primera línea contiene un comentario. Los caracteres // convierten el resto de
la línea en un comentario.
// comentarios en c#
Un bloque de texto también se puede convertir en comentario si se incluye entre

los caracteres /* y */. El ejemplo siguiente muestra esta opción.
/* "Hola Mundo! " programa en C#.
este es el primer programa echo en C# "Hola Mundo!" */
Método Principal
Una aplicación de consola en C# debe contener un método Main, en el cual se
inicia y se termina el control. Este método es donde se crean objetos y se ejecutan
otros métodos. El método Main es un metido static (Referencia de C#) que recide
dentro de una clase o un struct. En el ejemplo anterior vimos "Hola Mundo", recide

en una clase Main, Puede declararse el método Main de una de las maneras
siguientes:
 Puede devolver void.
static void Main()

{
//...
}
 También puede devolver un entero.
static int Main()

{
//...
return 0;
}
 Puede utilizar argumentos con cualquiera de los tipos devueltos.

{
//...
}
El parámetro del método Main, args, es una matriz de tipo string que contiene los argumentos de la línea
de comandos utilizados para llamar al programa. A diferencia de C++, la matriz no incluye el nombre del
archivo ejecutable (exe). Para obtener más información sobre cómo utilizar argumentos de la línea de
comandos, vea los ejemplos de Main() y argumentos de línea de comandos (Guía de programación de C#)
y Cómo: Crear y utilizar ensamblados desde la línea de comandos (C# y Visual Basic). La llamada a
ReadKey al final del método Main impide que la ventana de la consola se cierre antes de que pueda leer el
resultado al ejecutar el programa en modo de depuración presionando F5.
Publicado por Yhonatan Robles Vega No hay comentarios:

Etiquetas: algoritmo, C#, c# paso a paso, c# ya, ejemplos c#, Ejercicios C#, introduccion a
c#,vectores en c#, Visual Studio
Crear un Proyecto en C#

Cuando esté listo para empezar a programar, el primer paso es preparar un

proyecto. El proyecto contiene todo el material necesario para la aplicación.
Además de los archivos de código fuente, incluye los archivos de recursos, como
iconos, las referencias a archivos externos de los que depende la aplicación y los
datos de configuración, como los valores del compilador. Cuando se genera un
proyecto, Visual C# invoca al compilador de C# y otras herramientas internas para
crear un ensamblado ejecutable con los archivos del proyecto.
Codificación del problema con el lenguaje C#.
No debemos perder de vista que el fin último es realizar un programa de

computación que permita automatizar una actividad para que muchos procesos
sean desarrollados por la computadora.
El diagrama de flujo es un paso intermedio para poder ser interpretado por la
computadora.
El paso siguiente es la codificación del diagrama de flujo en un lenguaje de
computación, en nuestro caso emplearemos el lenguaje C#.
Lenguaje de computación: Conjunto de instrucciones que son interpretadas por

una computadora para realizar operaciones, mostrar datos por pantalla, sacar
listados por impresora, entrar datos por teclado, etc.
Consideraciones a tener en cuenta en cada proyecto.

Hay que tener en cuenta que el entorno de programación "Microsoft Visual C#
Express" o el "Visual Studio .Net Profesional" no han sido desarrollados pensando
en un principiante de la programación. Lo mismo ocurre con el propio lenguaje
C#, es decir su origen no tiene como objetivo el aprendizaje de la programación.
Debido a estos dos puntos veremos que a medida que avanzamos con el tutorial
muchos conceptos que iremos dejando pendientes se irán aclarando.
Veremos los pasos para la creación de un proyecto en C#.
Pasos a Seguir para crear un proyecto en C#
1. Abrimos Visual Studio 2010 Ultimate

2. Creamos un nuevo proyecto en Visual Studio 2010 Ultimate
3. En el siguiente cuadro nuevo proyecto elegimos Visual C# y luego elegimos

"Aplicación de consola" y le ponemos un Nuevo nombre al proyecto.

4. Podemos ver que el entorno nos generó automáticamente el esqueleto de

nuestro programa:
Como se ve en las imágenes ya tenemos nuestro primer proyecto creado en

Visual Studio 2010 Ultimate en el lenguaje de programacion Visual C#
Ejercicios Resueltos de Estructura Secuencial en C#

Ejemplo 1
Realizar la carga del lado de un cuadrado, mostrar por pantalla el perímetro del
mismo (El perímetro de un cuadrado se calcula multiplicando el valor del lado
por cuatro)
using System;
using System.Linq;
using System.Text;
namespace PerimetroCuadrado
{
class Program
{
{
int lado, perimetro;
string linea;
Console.Write("Ingrese el lado del cuadrado:");
lado = int.Parse(linea);
perimetro = lado * 4;
Console.Write("El perímetro del cuadrado es:");
Console.Write(perimetro);
Console.ReadKey();

}
}
}
Al ejecutar el código muestra el siguiente resultado
Ejemplo 2
Escribir un programa en el cual se ingresen cuatro números, calcular e informar

la suma de los dos primeros y el producto del tercero y el cuarto.
using System;
using System.Linq;
using System.Text;
namespace SumaProductos4Numeros
{
class Program
{
{
int num1, num2, num3, num4, suma, producto;
string linea;
Console.Write("Ingrese primer valor:");
num1 = int.Parse(linea);
Console.Write("Ingrese segundo valor:");
Console.Write("Ingrese tercer valor:");
Console.Write("Ingrese cuarto valor:");
suma = num1 + num2;
producto = num3 * num4;
Console.Write("La suma de los dos primero valores es:");
Console.WriteLine(suma);
Console.Write("El producto del tercer y cuarto valor es:");
Console.Write(producto);
Console.ReadKey();

}
}
}
Ejemplo 3
Realizar un programa que lea cuatro valores numéricos e informar su suma y

promedio.
using System;
using System.Linq;
using System.Text;
namespace SumaPromedio
{
class Program
{
{
int num1, num2, num3, num4, suma, promedio;
string linea;
suma = num1 + num2 + num3 + num4;
promedio = suma / 4;
Console.Write("La suma de los cuatro valores es:");
Console.Write("El promedio es:");
Console.Write(promedio);
Console.ReadKey();
}
}

Ejemplo 4
Se debe desarrollar un programa que pida el ingreso del precio de un artículo y la

cantidad que lleva el cliente. Mostrar lo que debe abonar el comprador.
using System;
using System.Linq;
using System.Text;
namespace CostoCompra
{
class Program
{
{
int cantidad;
float precio, importe;
string linea;
Console.Write("Ingrese la cantidad de artículos a llevar:");
cantidad = int.Parse(linea);
Console.Write("Ingrese el valor unitario del producto:");
precio = float.Parse(linea);
importe = precio * cantidad;
Console.Write("El importe total a pagar es:");
Console.Write(importe);
Console.ReadKey();
}
}
}

Publicado por Yhonatan Robles Vega 1 comentario:

Etiquetas: arreglos en c#, C#, c# paso a paso, c# ya, condiciones en c#, ejemplos c#, Ejercicios
C#,if else en c#, introduccion a c#
Estructura Secuencial en C#
Estructura Secuencial en C#
Cuando en un problema sólo participan operaciones, entradas y salidas se la
denomina una estructura secuencial.
Los problemas diagramados y codificados previamente emplean solo estructuras

secuenciales.
La programación requiere una práctica ininterrumpida de diagramación y
codificación de problemas.

Ejemplo 1
Realizar la carga de dos números enteros por teclado e imprimir su suma y su

producto.
using System;
using System.Linq;
using System.Text;
namespace SumaProductoNumeros
{
class Program
{

{
int num1, num2, suma, producto;
string linea;
suma = num1 + num2;
Console.Write("La suma de los dos valores es:");
Console.Write("El producto de los dos valores es:");
Console.WriteLine(producto);
Console.ReadKey();
}
}
}
Recordemos que tenemos que seguir todos los pasos vistos para la creación de un
proyecto.
Algunas cosas nuevas que podemos notar:
 Podemos definir varias variables en la misma línea: int num1, num2,
suma, producto;
 Si llamamos a la función WriteLine en lugar de Write, la impresión
siguiente se efectuará en la próxima línea: Console.WriteLine(suma);
Estructuras Condicionales en C#
Estructuras Condicionales en C#
Hemos visto hasta ahora que los programas van ejecutando las líneas de código
con orden. Sin embargo, hay muchas situaciones en las que es preciso alterar ese
orden, o bien puede ocurrir que sea necesario que se efectúen una serie de
operaciones que pueden ser distintas en otras circunstancias. Por ejemplo, si el
programa pide una clave de acceso, deberá continuar con la ejecución normal en
caso de que la clave introducida por el usuario sea correcta, y deberá salir del
mismo en caso contrario. Pues bien: para todas estas cuestiones que, por otra parte,
son muy frecuentes, tenemos las estructuras de control de flujo.
En C# contamos con varias de estas estructuras, así que las iremos explicando con
calma una a una, empezando en esta entrega con las estructuras condicionales. De
nuevo he de avisar a los programadores de C/C++: el comportamiento de algunas

de estas estructuras cambia ligeramente en C#, así que leed esta entrega
atentamente, pues de lo contrario podéis encontraros con varios problemas a la
hora de usarlas.
Por supuesto que en un problema se combinan estructuras secuenciales y
condicionales.
Estructura Condicional if - else en c#
Es la instrucción condicional mas usada en los diversos lenguajes de
programación, su formato completo y de trabajo en C Sharp es:
cargar o asignar la variable de condición;
if (condición)
{ grupo cierto de instrucciones;}
else
{ grupo falso de instrucciones; };
Tenemos 2 casos de estructuras condicionales y son:
1. estructuras condicionales simples

2. estructuras condicionales compuesta
Estructura condicional simple.
Cuando se presenta la elección tenemos la opción de realizar una actividad o no
realizar ninguna.
Representación gráfica:

Podemos observar: El rombo representa la condición. Hay dos opciones que se

pueden tomar. Si la condición da verdadera se sigue el camino del verdadero, o sea
el de la derecha, si la condición da falsa se sigue el camino de la izquierda.
Se trata de una estructura condicional simple porque por el camino del verdadero
hay actividades y por el camino del falso no hay actividades.
Por el camino del verdadero pueden existir varias operaciones, entradas y salidas,
inclusive ya veremos que puede haber otras estructuras condicionales.
Etiquetas: algoritmo en c#, arreglos en c#, c# paso a paso, c# ya, condiciones en c#, Ejercicios
C#,ejercicios de matrices en C#, if else en c#
Ejemplos de Estructura Secuencial en c#

Ejemplos de Estructura Secuencial en c#
Ejemplo 1
Realizar un programa que lea cuatro valores numéricos e informar su suma y

promedio.
using System;
using System.Linq;
using System.Text;
namespace SumaPromedio
{
class Program
{


{
int num1, num2, num3, num4, suma, promedio;
string linea;
suma = num1 + num2 + num3 + num4;
Console.Write("La suma de los cuatro valores es:");
Console.ReadKey();
}
}
}
Ejemplo 2
Se debe desarrollar un programa que pida el ingreso del precio de un artículo y la

cantidad que lleva el cliente. Mostrar lo que debe abonar el comprador.
using System;
using System.Linq;
using System.Text;
namespace CostoCompra
{
class Program
{
{
int cantidad;

float precio, importe;

string linea;
Console.Write("Ingrese la cantidad de artículos a llevar:");
cantidad = int.Parse(linea);
Console.Write("Ingrese el valor unitario del producto:");
precio = float.Parse(linea);
importe = precio * cantidad;
Console.Write("El importe total a pagar es:");
Console.Write(importe);
Console.ReadKey();
}
}
}
Operadores Aritméticos en C#
Operadores Aritméticos en C#
En una condición deben disponerse únicamente variables, valores constantes y
operadores relacionales.
 Operadores Relacionales:
> (mayor)
< (menor)
>= (mayor o igual)
<= (menor o igual)
== (igual)
!= (distinto)
 Operadores Matemáticos
+ (más)
- (menos)
* (producto)
/ (división)
% (resto de una división) Ej.: x=13%5; {se guarda 3}
Hay que tener en cuenta que al disponer una condición debemos seleccionar que
operador relacional se adapta a la pregunta.
Ejemplos:
Se ingresa un número multiplicarlo por 10 si es distinto a 0. (!=)
Se ingresan dos números mostrar una advertencia si son iguales. (==)
Los problemas que se pueden presentar son infinitos y la correcta elección del
operador sólo se alcanza con la práctica intensiva en la resolución de problemas.

Ejercicios Resueltos de Estructura Condicional Compuesta
Ejemplo 1
Realizar un programa que solicite ingresar dos números distintos y muestre por
pantalla el mayor de ellos.
using System;
using System.Linq;
using System.Text;
namespace EstructuraCondicionalCompuesta1
class Program
int num1, num2;
string linea;
if (num1 > num2)
Console.Write(num1);
else
Console.ReadKey();

Etiquetas: c# paso a paso, ejemplos c#, ejemplos con operadores en c#, Ejercicios C#, if else en
c#,operadores aritmeticos en c#, operadores en c#
Ejercicios Resueltos de Estructura Condicional en C#

Ejercicios Resueltos de Estructura Condicional en C#
Ejemplo 1
using System;
using System.Linq;
using System.Text;
class Program
int num1, num2;
string linea;

if (num1 > num2)
else
Console.ReadKey();
Ejemplo 2
using System;
using System.Linq;
using System.Text;
class Program

int num1, num2;
string linea;
if (num1 > num2)
else
Console.ReadKey();
Ejemplo de Promedio de Notas en C#

Se ingresan tres notas de un alumno, si el promedio es mayor o igual a siete
mostrar un mensaje "Promocionado".
using System;
using System.Linq;

using System.Text;
namespace EstructuraCondicionalSimple2
class Program
int nota1, nota2, nota3;
string linea;
Console.Write("Ingrese primer nota:");
nota1 = int.Parse(linea);
Console.Write("Ingrese segunda nota:");
Console.Write("Ingrese tercer nota:");
int promedio;
promedio = (nota1 + nota2 + nota3) / 3;
if (promedio >= 7)
Console.Write("Promocionado");
Console.ReadKey();

Etiquetas: c# paso a paso, condiciones en c#, ejemplos con operadores en c#introduccion a

c#, if else en c#, operadores aritmeticos en c#, operadores en c#
Ejemplos de If - Else en C#
Ejemplos de If - Else en C#
Ejemplo 1
Realizar un programa que lea por teclado dos números, si el primero es mayor al
segundo informar su suma y diferencia, en caso contrario informar el producto y
la división del primero respecto al segundo.
using System;
using System.Linq;
using System.Text;
class Program
int num1, num2;
string linea;
if (num1 > num2)
int suma, diferencia;

suma = num1 + num2;
diferencia = num1 - num2;
Console.Write("La suma de los dos valores es:");
Console.Write("La diferencia de los dos valores es:");
Console.WriteLine(diferencia);
else
int producto, division;
division = num1 / num2;
Console.Write("El producto de los dos valores es:");
Console.WriteLine(producto);
Console.Write("La división de los dos valores es:");
Console.WriteLine(division);
Console.ReadKey();
Ejemplo 2

Se ingresa por teclado un número positivo de uno o dos dígitos (1..99) mostrar
un mensaje indicando si el número tiene uno o dos dígitos.
using System;
using System.Linq;
using System.Text;
class Program
int num;
string linea;
Console.Write("Ingrese un valor entero de 1 o 2 dígitos:");
num = int.Parse(linea);
if (num < 10)
Console.Write("Tiene un dígito");
else
Console.Write("Tiene dos dígitos");
Console.ReadKey();

Ejercicios Resueltos de Estructura Condicional

Anidada en C#
Ejercicios Resueltos de Estructura condicional anidad en c#
Ejemplo 1
Realizar un programa que pida tres notas de un alumno, calcule el promedio e

imprima lo siguiente:
Si el promedio es >10 mostrar "Aprobado".
Si el promedio es >7 y <=10 mostrar "Desaprobado".
Si el promedio es <7 mostrar "Reprobado".
using System;
using System.Linq;
using System.Text;
namespace EstructuraCondicionalAnidada1
class Program
string linea;
Console.Write("Ingrese la primera nota:");
Console.Write("Ingrese la segunda nota:");
Console.Write("Ingrese la tercera nota:");

int promedio = (nota1 + nota2 + nota3) / 3;
if (promedio > 10)
Console.Write("Aprobado");
else
if (promedio > 7)
Console.Write("Desaprobado");
else
Console.Write("Reprobado");
Console.ReadKey();
Ejemplo 2

Realizar un programa que me muestre de tres números ingresados por el

teclado el mayor numero
using System;
using System.Linq;
using System.Text;
class Program
int num1, num2, num3;
string linea;
Console.Write("Ingrese primer numero:");
Console.Write("Ingrese segunda numero:");
Console.Write("Ingrese tercer numero:");
if (num1 > num2)
if (num1 > num3)
Console.Write("El mayor es: "+num1);
else
Console.Write("El mayor es: " + num3);

else
if (num2 > num3)
else
Console.ReadKey();
Etiquetas: c# básico, c# paso a paso, condiciones en c#, ejemplos con operadores en

c#introduccion a c#, ejemplos de estructura anidada en c#, Ejercicios C#, estructura anidada en
c#, operadores en c#, vectores en c#
Estructura Condicional Anidada en C#

Estructura Condicional Anidada en C#
En ocasiones dentro de una estructura if pueda existir otras estructuras if. A esa
estructura if combinada se le denomina if anidada.

El diagrama de flujo que se presenta contiene dos estructuras condicionales.

Ejercicios Resueltos de Estructura condicional anidada en c#
Ejemplo 1
Realizar un programa que pida tres notas de un alumno, calcule el promedio e

imprima lo siguiente:
Si el promedio es >10 mostrar "Aprobado".
Si el promedio es >7 y <=10 mostrar "Desaprobado".
Si el promedio es <7 mostrar "Reprobado".
using System;
using System.Linq;
using System.Text;
class Program
string linea;

Console.Write("Ingrese la primera nota:");
Console.Write("Ingrese la segunda nota:");
Console.Write("Ingrese la tercera nota:");
int promedio = (nota1 + nota2 + nota3) / 3;
if (promedio > 10)
Console.Write("Aprobado");
else
if (promedio > 7)
Console.Write("Desaprobado");
else
Console.Write("Reprobado");
Console.ReadKey();

Estructura condicional compuesto en c#

Estructura condicional compuesto en c#
En este capítulo se revisan los distintos métodos con los que C # controla el flujo
lógico de un programa.
Como se revisó en el capítulo anterior, los operadores relaciones binarios que se
usan son:
==, !=, <, <=, > y >=
además los operadores lógicos binarios:
||, &&, ?
y el operador lógico unario de negación !, que sólo toma un argumento.

Operador || en C#
Traducido se lo lee como “O”. Si la condición 1 es Verdadera O la condición 2 es
Verdadera, luego ejecutar la rama del Verdadero.
Cuando vinculamos dos o más condiciones con el operador “Or", con que una de
las dos condiciones sea Verdadera alcanza para que el resultado de la condición
compuesta sea Verdadero.
operador && en C#
Traducido se lo lee como “Y”. Si la Condición 1 es verdadera Y la condición 2 es
verdadera luego ejecutar la rama del verdadero.
Cuando vinculamos dos o más condiciones con el operador “&&”, las dos
condiciones deben ser verdaderas para que el resultado de la condición
compuesta de Verdadero y continúe por la rama del verdadero de la estructura
condicional.
La utilización de operadores lógicos permiten en muchos casos plantear
algoritmos más cortos y comprensibles.
Operador ? en C#

El operador ternario condicional ? es más eficiente que la sentencia if. El

operador ? tiene el siguiente formato:
expresion1 ? expresion 2 : expresion3;
Que es equivalente a la siguiente expresión:
if (expresion1) then expresion2 else expresion3;
Por ejemplo, para asignar el máximo de a y b a la variable z, usando ?,

tendríamos:
z = (a>b) ? a : b;
que es lo mismo que:
if (a > b)
z = a;
else
z = b;
El uso del operador ? para reemplazar las sentencias if ... else no se restringe sólo
a asignaciones, como en el ejemplo anterior. Se pueden ejecutar una o más
llamadas de función usando el operador ? poniéndolas en las expresiones que
forman los operandos.
Etiquetas: c# básico, condiciones en c#, ejemplos con operadores en c#, ejemplos de

estructura anidada en c#, operadores en c#
Ejemplos de Estructura Anidadas en C#

Ejemplos de Estructura Anidadas en C#
Ejemplo 1
Realizar un programa que permita ingresar un número entero positivo por el

teclado y cuente cuantas cifras tiene.

using System;
using System.Linq;
using System.Text;
class Program
int num;
string linea;
Console.Write("Ingrese un numero positivo: ");
if (num < 10)
Console.Write("El numero tiene un dígito");
else
if (num < 100)
Console.Write("El numero tiene dos dígitos");
else
if (num < 1000)
Console.Write("el numero tiene tres dígitos");
else
Console.Write("El numero tiene mas de tres digitos");

Console.ReadKey();
Ejemplo 2
Realizar un programa que pida ingresar por el teclado un numero entero, y que
indique si el número es positivo, nulo o negativo.
using System;
using System.Linq;
using System.Text;
class Program
int num;
string linea;

Console.Write("Ingrese un numero:");
if (num == 0)
Console.Write("El numero es cero");
else
if (num > 0)
Console.Write("El numero es positivo");
else
Console.Write("El numero es negativo negativo");
Console.ReadKey();
Ejercicios Resueltos de Estructura While en C#

Ejercicios Resueltos de Estructura While en C#
Ejemplo 1
Realizar un programa que imprima en pantalla los números del 1 al 50.
using System;

using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile
class Program
int x;
x = 1;
while (x <= 50)
Console.Write(x);
Console.Write(" , ");
x = x + 1;
Console.ReadKey();
Ejemplo 2

Realizar un programa que dado un numero n entero, imprima

consecutivamente asta n
using System;
using System.Linq;
using System.Text;
class Program
int n, x;
string linea;
Console.Write("Ingrese el valor de n:");
n = int.Parse(linea);
x = 1;
while (x <= n)
Console.Write(x);
Console.Write(" , ");
x = x + 1;
Console.ReadKey();

Etiquetas: bucles en c#, C#, c# básico, ejercicios resueltos de c#, ejercicios while en
c#, Estructura repetitiva while en c#, problemas while en c#, while en c#
Estructura Repetitiva While en C#

Estructura Repetitiva While en C#
Hasta en momento hemos visto estructuras secuenciales y condicionales, ahora
estudiaremos las estructuras repetitivas en c#.
Una estructura repetitiva permite ejecutar una instrucción o un conjunto de

instrucciones varias veces, según la condición establecida en dicho bucle.
Veamos una gráfica de la estructura while en diagramas de flujo.
Nota: Podemos observar que el bloque repetitivo puede no ejecutarse ninguna

vez si la condición retorna falso la primera vez.

La variable x debe estar inicializada con algún valor antes que se ejecute la
operación x=x + 1 en caso de no estar inicializada aparece un error de
compilación.
La sintaxis en pseudocódigo es la siguiente:
mientras condición hacer

instrucción
fin mientras
Ejemplos de Estructura While en C#

Ejemplos de Estructura While en C#
Ejemplo 1
Desarrollar un programa que imprima los múltiplos de 3 del 1 al 200
using System;
using System.Linq;
using System.Text;
class Program
int mult;
mult = 3;
while (mult <= 200)
Console.Write(mult);
Console.Write(", ");

mult = mult + 3;
Console.ReadKey();
Ejemplo 2
Realizar un programa que nos imprima la factorial de un numero dado desde el

teclado
using System;
using System.Linq;
using System.Text;
class Program
int fac=1,x,n;

string linea;
x = 1;
Console.Write("Ingrese un numero entero: ");
while (x <= n)
fac = fac * x;
x = x + 1;
Console.Write("La factorial es: "+fac);
Console.ReadKey();
Etiquetas: bucles en c#, C#, ejemplos c#, ejercicios resueltos de c#, Estructura repetitiva while
en c#, Estructura While en C#, problemas while en c#, while en c#
Problemas de Estructura While en C#

Problemas de Estructura While en C#
Ejemplo 1
Realizar un programa que permita ingresar 8 números y nos muestre la suma y

el promedio de dichos números
using System;

using System.Linq;
using System.Text;
class Program
int x, suma, valor, promedio;
string linea;
x = 1;
suma = 0;
while (x <= 8)
Console.Write("Ingrese valor "+x+":");
valor = int.Parse(linea);
suma = suma + valor;
x = x + 1;
Console.Write("La suma es:");
Console.ReadKey();

Ejemplo 2
Desarrollar un programa que permita ingresar n números enteros y luego nos

imprima cuántos valores fueron pares y cuántos impares.
using System;
using System.Linq;
using System.Text;
class Program
int n, x, valor, pares, impares;
string linea;
x = 1;
pares = 0;
impares = 0;
Console.Write("Cuantos el valor de n:");

while (x <= n)
Console.Write("Ingrese el valor "+x+": ");
valor = int.Parse(linea); ;
if (valor % 2 == 0)
pares = pares + 1;
else
impares = impares + 1;
x = x + 1;
Console.Write("Cantidad de pares:");
Console.WriteLine(pares);
Console.Write("Cantidad de impares:");
Console.Write(impares);
Console.ReadKey();
Estructura repetitiva For en C#

Estructura repetitiva For en C#
Anteriormente vimos la estructura repetitiva while con la que se puede resolver

cualquier tipo de problemas que tengan que ver con estructuras repetitivas,
ahora veremos la estructura repetitiva for que es un bucle muy fácil de utilizar.
En general, la estructura for se usa en aquellas situaciones en las cuales
conocemos la cantidad de veces que queremos que se ejecute el bloque de
instrucciones.
En su forma más típica y básica, esta estructura requiere una variable entera que
cumple la función de un contador de vueltas. En la sección indicada como
"inicialización contador", se suele colocar el nombre de la variable que hará de
contador, asignándole a dicha variable un valor inicial. En la sección de
"condición" se coloca la condición que deberá ser verdadera para que el ciclo
continúe (en caso de un falso, el ciclo se detendrá). Y finalmente, en la sección de
"incremento contador" se coloca una instrucción que permite modificar el valor
de la variable que hace de contador (para permitir que alguna vez la condición
sea falsa)
Las variables a utilizar en el bucle for pueden ser cualquiera.
Veamos un ejemplo del bucle for en diagramas de flujo.

Ahora para entender mas sobre las estructuras repetitivas for vamos a ver
algunos ejemplos que nos ayudaran a entender mejor el tema.
Etiquetas: algoritmo en c#, bucle for en c#, bucles en c#, C#, c# paso a paso, ejercicios for en
c#,ejercicios resueltos de c#, Estructura repetitiva For en C#, For en C#
Factorial de un Numero en C#
Realizar un programa que nos imprima la factorial de un numero dado desde el
teclado
using System;
using System.Linq;
using System.Text;
class Program
int fac=1,x,n;
string linea;
x = 1;
while (x <= n)
fac = fac * x;
x = x + 1;
Console.ReadKey();

Ejemplos del Bucle For en C#

Ejemplos del Bucle For en C#
Ejemplo 1
Desarrollar un programa que muestre la tabla de multiplicar de un numero

ingresado por el teclado del 1 al 15
using System;
using System.Linq;
using System.Text;
class Program
int n;
string linea;
Console.Write("Ingrese multiplicador: ");
for(int i=1; i<=15; i++ ) {
Console.Write(i+" x "+n+" = "+i*n+"\n");

Console.ReadKey();
Ejemplo 2
Realizar un programa que permita ingresar n números enteros por el teclado y

se desea conocer:
a) La cantidad de números positivos.
b) La cantidad de números negativos.
c) La cantidad de números pares.
d)La cantidad de números impares
using System;
using System.Linq;

using System.Text;
class Program
int n,valor,positivos,negativos,pares,impares;
positivos = 0;
negativos = 0;
pares = 0;
impares = 0;
string linea;
Console.Write("Ingrese valor de n: ");
for(int i=1; i<=n; i++ ) {
Console.Write("Ingrese numero "+i+": ");
if (valor > 0)
positivos++;
else
if (valor < 0)
negativos++;
if (valor % 2 == 0)
pares++;

else
if (valor % 2 != 0)
impares++;
Console.WriteLine("Cantidad de numeros negativos: "+negativos);
Console.WriteLine("Cantidad de numeros positivos: "+positivos);
Console.WriteLine("Cantidad de numeros pares: "+pares);
Console.WriteLine("Cantidad de numeros impares: "+impares);
Console.ReadKey();
Etiquetas: algoritmo en c#, bucle for en c#, bucles en c#, ejemplos c#, Ejercicios C#, ejercicios
for en c#, Estructura repetitiva For en C#, For en C#, introducción a c#
Ejercicios Resueltos de Estructura Repetitiva For en

C#
Ejercicios Resueltos de Estructura Repetitiva For en C#
Ejemplo 1
Realizar un programa que permita obtener la factorial de un numero entero

ingresado por el teclado
using System;
using System.Linq;
using System.Text;
class Program
int fac=1,n;
string linea;
for(int i=1; i<=n; i++ ) {
fac = fac * i;
Console.ReadKey();

Ejemplo 2
Realizar un programa que permita imprimir por pantalla los números múltiplos
de 5, establecer el rango por el teclado
using System;
using System.Linq;
using System.Text;
class Program
int n;
string linea;
Console.Write("Los multiplos de 5 son: ");
Console.Write("\n");
for(int i=1; i<=n; i++ ) {
if (i % 5 == 0)
Console.Write(i+", ");
Console.ReadKey();

Estructura repetitiva Do While en C#

Estructura repetitiva Do While en C#
La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una
vez su bloque repetitivo, a diferencia del while o del for que podían no ejecutar
el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo
menos una vez se ejecutará el bloque repetitivo.
La condición de la estructura está abajo del bloque a repetir, a diferencia del while
o del for que está en la parte superior.
Do en C#
La instrucción do ejecuta una instrucción o un bloque de instrucciones entre {}
repetidamente hasta que una expresión especificada se evalúe como false.
Etiquetas: bucle do while en c#, bucles en c#, c sharp, C#, do while en c#, ejercicios de do while
en c#, ejercicios de estructuras condicionales en c#, ejercicios resueltos de c#
Tabla de Multiplicar en C#
Tabla de Multiplicar en C#
Desarrollar un programa que muestre la tabla de multiplicar de un numero
ingresado por el teclado del 1 al 15
using System;
using System.Linq;
using System.Text;
class Program
int n;
string linea;
Console.Write("Ingrese multiplicador: ");
for(int i=1; i<=15; i++ ) {
Console.Write(i+" x "+n+" = "+i*n+"\n");
Console.ReadKey();

Ejemplo de Do While en C#
Ejemplo de Do While en C#
En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada
cuenta corriente se conoce: número de cuenta y saldo actual. El ingreso de datos
debe finalizar al ingresar un valor negativo en el número de cuenta.
Se pide realizar un programa que lea los datos de las cuentas corrientes e
informe:
a)De cada cuenta: número de cuenta y estado de la cuenta según su saldo,
sabiendo que:
Estado de la cuenta 'Acreedor' si el saldo es >0.
'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.
b) La suma total de los saldos acreedores.
using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
class Program
int cuenta;

float saldo, suma;
string linea;
suma = 0;
do
Console.Write("Ingrese número de cuenta:");
cuenta = int.Parse(linea);
if (cuenta >= 0)
Console.Write("Ingrese saldo:");
saldo = float.Parse(linea);
if (saldo > 0)
Console.WriteLine("Saldo Acreedor.");
suma = suma + saldo;
else
if (saldo < 0)
Console.WriteLine("Saldo Deudor.");
else
Console.WriteLine("Saldo Nulo.");
} while (cuenta >= 0);
Console.Write("Total de saldos Acreedores:");
Console.Write(suma);
Console.ReadKey();

Publicado por Yhonatan Robles Vega 2 comentarios:
Etiquetas: bucle do while en c#, bucles en c#, c sharp, C#, do while en c#, ejercicios de do while
en c#, ejercicios de estructuras condicionales en c#, ejercicios resueltos de c#
Ejercicios de la Estructura Do While en C#

Ejercicios Resueltos de Estructura
Repetitiva Do While en C#
Realizar un programa que pida una serie de números y al finalizar que saque el
promedio de dichos números (0 para finalizar)
using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
class Program
int suma, cant, valor, promedio;

string linea;
suma = 0;
cant = 0;
do
Console.Write("Ingrese un nimero (0 para finalizar):");
if (valor != 0)
suma = suma + valor;
cant++;
} while (valor != 0);
if (cant != 0)
promedio = suma / cant;
Console.Write("El promedio de los valores ingresados es:");
else
Console.Write("No se ingresaron valores ");
Console.ReadLine();

Ejercicios con Cadena de Caracteres en C#

Ejercicios con Cadena de Caracteres en
C#
Ejemplo 1
Realizar un programa que permita el ingreso del nombre y edad de dos personas.
Mostrar el nombre de la persona con mayor edad.
using System;
using System.Linq;
using System.Text;
namespace CadenaDeCaracteres
class Program
String nombre1, nombre2;
int edad1, edad2;
String linea;
Console.Write("Ingrese el nombre 1:");
nombre1 = Console.ReadLine();
Console.Write("Ingrese edad 1:");
edad1 = int.Parse(linea);
Console.Write("Ingrese el nombre 2:");
if (edad1 > edad2)
Console.Write("La persona de mayor edad es:"+nombre1);

else
Console.Write("La persona de mayor edad es:"+nombre2);
Console.ReadKey();
Ejemplo 2
Realizar un programa que permita el ingreso del apellido, nombre y edad de dos
personas. Mostrar el nombre de la persona con mayor edad.
using System;
using System.Linq;
using System.Text;
class Program
string apenom1, apenom2;
int edad1, edad2;
string linea;
Console.Write("Ingrese apellido y nombre 1:");

apenom1 = Console.ReadLine();
Console.Write("Ingrese apellido y nombre 2:");
apenom2 = Console.ReadLine();
Console.Write("La persona de mayor edad es:");
if (edad1 > edad2)
Console.Write(apenom1);
else
Console.Write(apenom2);
Console.ReadKey();
Etiquetas: c# ejercicios resueltos, cadena de caracteres en c#, cadenas en c#, caracteres en

c#,ejemplos en c#, ejercicios con cadena de caracteres en c#, operadores en c#, vectores en c#
Cadena de Caracteres en C#
Cadena de Caracteres en C#
Una cadena de C# es una matriz de caracteres que se declara utilizando la

palabra clave string. Un literal de cadena se declara utilizando las comillas, como
se muestra en el siguiente ejemplo:
string s = "Hola, Mundo!";

Puede extraer subcadenas y concatenar cadenas de la siguiente manera:
string s1 = "orange";
string s2 = "red";
s1 += s2;
System.Console.WriteLine(s1); // outputs "orangered"
s1 = s1.Substring(2, 5);
System.Console.WriteLine(s1); // outputs "anger"
Los objetos de cadena son inmutables, lo que significa que no se pueden cambiar
una vez creados. Los métodos que actúan sobre las cadenas, devuelven los
nuevos objetos de cadena. En el ejemplo anterior, cuando el contenido de s1 y s2
se concatenan para formar una sola cadena, las dos cadenas que contienen
"orange" y "red" no se modifican.
El operador += crea una nueva cadena que contiene el contenido combinado.
Como resultado, s1 ahora hace referencia a una cadena totalmente diferente.
Todavía existe una cadena que sólo contiene "orange" , pero deja de hacerse
referencia a ella cuando se concatena s1.
Tenga cuidado cuando cree referencias a cadenas. Si crea una referencia a una
cadena y después "modifica" la cadena, la referencia seguirá señalando al objeto
original y no al nuevo objeto que se creó cuando se modificó la cadena.
Carácter de escape
Los caracteres de escape como "\n" y (nueva línea) y "\t" (tabulador) se pueden
incluir en cadenas. La línea:
string hello = "Hola\nMundo!";
equivale a:
Hola
Mundo!
ToString()

Al igual que todos los objetos derivados de Object, las cadenas proporcionan el
método ToString, que convierte un valor en una cadena. Este método se puede
utilizar para convertir valores numéricos en cadenas de la siguiente manera:
int year = 1999;

string msg = "Eve was born in " + year.ToString();
System.Console.WriteLine(msg); // outputs "Eve was born in 1999"
por ahora solo nos interesa la mecánica para trabajar con cadenas de caracteres.
Para ello veremos algunos ejemplos para el uso de cadena de caracteres
Ejercicios Resueltos de Cadena de Caracteres en C#

Ejemplo 1
Realizar un programa que nos pida dos nombres por el teclado y que los compare
si son iguales o no
using System;
using System.Linq;
using System.Text;
class Program
string nombre1, nombre2;
Console.Write("Ingrese primer nombre:");
Console.Write("Ingrese segundo nombre:");
if (nombre1 == nombre2)
Console.Write("Los nombres son iguales");
else

Console.Write("Los nombres son distintos");
Console.ReadKey();
Ejercicios Resueltos de Clases en C#

Ejercicios Resueltos de Clases en C#
Ejemplo 1
Desarrollar un programa que permita ingresar los lados de un triángulo e
implemente los siguientes métodos: inicializar los atributos, imprimir el valor del
lado mayor y otro método que muestre si es equilátero o no.
using System;
using System.Linq;
using System.Text;
namespace PruebaClase
class Triangulo
private int lado1, lado2, lado3;
//Metodo inicializar
public void Inicializar()
string linea;
Console.Write("Ingrese lado 1:");
lado1 = int.Parse(linea);

//Metodo lado mayor
public void LadoMayor()
Console.Write("Lado mayor:");
if (lado1 > lado2 && lado1 > lado3)
Console.WriteLine(lado1);
else
if (lado2 > lado3)
else
//Metodo es equilatero
public void EsEquilatero()
if (lado1 == lado2 && lado1 == lado3)
Console.Write("Es un triángulo equilátero");

else
Console.Write("No es un triángulo equilátero");
Triangulo triangulo1 = new Triangulo();
triangulo1.Inicializar();
triangulo1.LadoMayor();
triangulo1.EsEquilatero();
Console.ReadKey();
Este problema requiere definir tres atributos de tipo entero donde almacenamos
los valores de los lados del triángulo:
private int lado1, lado2, lado3;
El primer método que deberá llamarse desde la main es el Inicializar donde

cargamos los tres atributos por teclado:
public void Inicializar() {}

El método LadoMayor muestra el valor mayor de los tres enteros ingresados:

public void LadoMayor() {}
Como podemos observar cuando un problema se vuelve más complejo es más

fácil y ordenado separar los distintos algoritmos en varios métodos y no codificar
todo en la main.
El último método de esta clase verifica si los tres enteros ingresados son iguales:
public void EsEquilatero() {}
En la main creamos un objeto de la clase Triangulo y llamamos los métodos

respectivos:
Triangulo triangulo1 = new Triangulo();
triangulo1.Inicializar(); //llamando al método inicializar()
triangulo1.LadoMayor(); //llamando al método LadoMayor()
triangulo1.EsEquilatero(); //llamando al método EsEquilatero()
Console.ReadKey();
Ejemplo 2
Realizar un programa que tenga una clase que permita ingresar el nombre y la
edad de una persona. Mostrar los datos ingresados. Imprimir un mensaje si es
mayor de edad (edad>=18)
using System;
using System.Linq;
using System.Text;
class Persona
private string nombre;

private int edad;
//Método Inicializar()
Console.Write("Ingrese nombre:");
nombre = Console.ReadLine();
string linea;
Console.Write("Ingrese edad:");
edad = int.Parse(linea);
//Método Imprimir()
Console.Write("Nombre:");
Console.WriteLine(nombre);
Console.Write("Edad:");
Console.WriteLine(edad);
//Método es EsMayorEdad()
public void EsMayorEdad()
if (edad >= 18)
Console.Write("Es mayor de edad");
else
Console.Write("No es mayor de edad");
Console.ReadKey();
// Main principal del programa

Persona per1 = new Persona();
per1.Inicializar(); //Llamando al método Inicializar();
per1.Imprimir(); //Llamando al método Imprimir();
per1.EsMayorEdad(); //Llamando al método EsMayorEdad
Etiquetas: algoritmo, c# completo clases, c# ejercicios resueltos, c# ejercicios resueltos de

clases,c# ya, clases en c#, declaración de clases en c#, ejercicios con clases en c#, métodos en
c#, Visual Studio
Clases en C#
La programación orientada a objetos se basa en la programación de clases; a
diferencia de la programación estructurada, que está centrada en las funciones.
Clase en C#
Una clase es un molde del que luego se pueden crear múltiples objetos, con
similares características.
Una clase es una plantilla (molde), que define atributos (variables) y métodos
(funciones)
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero
luego, cada objeto tendrá sus propios valores y compartirán las mismas
funciones.

Debemos crear una clase antes de poder crear objetos (instancias) de esa clase.
Al crear un objeto de una clase, se dice que se crea una instancia de la clase o un
objeto propiamente dicho.
La sintaxis de una clase en c# es:

class [nombre de la clase] {
[atributos o variables de la clase]
[métodos o funciones de la clase]
[main]
}
Definición de un Método en C#
Un método es un conjunto de instrucciones a las que se les asocia un nombre de
modo que si se desea ejecutarlas basta referenciarlas a través de dicho nombre en
vez de tener que escribirlas. Dentro de estas instrucciones es posible acceder con
total libertad a la información almacenada en los campos pertenecientes a la clase
dentro de la que el método se ha definido, los métodos permiten manipular los
datos almacenados en los objetos.
Estructura de una Clase en C#

Los componentes principales de una clase, que a partir de ahora llamaremos
miembros, son:
Atributos, que determinan una estructura de almacenamiento para cada objeto
de la clase.
Métodos, que no son mas que operaciones aplicables sobre los objetos.
Objetos en C#
Declaración de Objetos en C#
Cuando uno plantea una clase en lugar de especificar todo el algoritmo en un
único método (lo que hicimos en los primeros pasos de este tutorial) es dividir
todas las responsabilidades de las clase en un conjunto de métodos.
Declaración de una clase y un Objeto

Declaración de varios Objetos dentro de un Clase

Ejemplo:
Definir tres clases llamada tren, avión y barco, luego definir una clase llamada
transporte y en ella definir los objetos de las clases anteriores.
Otra forma de declarar objetos definidos como arreglos de objetos

Etiquetas: c# ejercicios resueltos, declaración de objetos en c# clases y objetos en

C#, definición de un objeto en c#, ejemplos de objetos en c#, ejercicios con objetos en c#
Ejemplos de Clases en C#
Ejemplos de Clases en C#
Ejemplo 1
Desarrollar un programa que tenga una clase que represente un Cuadrado y

tenga los siguientes métodos: ingresar valor a su lado, imprimir su perímetro y
su superficie.
using System;
using System.Linq;
using System.Text;
class Cuadrado
private int lado;
//método Inicializar()
Console.Write("Ingrese valor del lado:");
string linea;

lado = int.Parse(linea);
//Método ImprimirPerimetro()
public void ImprimirPerimetro()
int perimetro;
perimetro = lado * 4;
Console.WriteLine("El perímetro es:" + perimetro);
//Método ImprimirSuperficie()
public void ImprimirSuperficie()
int superficie;
superficie = lado * lado;
Console.WriteLine("La superficie es:" + superficie);
//Main() principal del programa
Cuadrado cuadrado1 = new Cuadrado();
cuadrado1.Inicializar(); //Llamando al método Inicializar();
cuadrado1.ImprimirPerimetro(); //Llamando
al método ImprimirPerimetro();
cuadrado1.ImprimirSuperficie(); //Llamando
al método ImprimirSuperficie();
Console.ReadKey();

Ejemplo 2
Implementar la clase operaciones. Se deben ingresar los dos valores enteros,

calcular su suma, resta, multiplicación y división, cada una en un método, e
imprimir dichos resultados.
using System;
using System.Linq;
using System.Text;
class Operaciones
private int valor1, valor2;
// Método Inicializar()
string linea;
valor1 = int.Parse(linea);
Console.Write("Ingrese segundo numero:");
valor2 = int.Parse(linea);
// Método Sumar()
public void Sumar()

int suma;
suma = valor1 + valor2;
Console.WriteLine("La suma es:" + suma);
//Método Restar()
public void Restar()
int resta;
resta = valor1 - valor2;
Console.WriteLine("La resta es:" + resta);
// Método Multiplicar()
public void Multiplicar()
int multiplicacion;
multiplicacion = valor1 * valor2;
Console.WriteLine("La multiplicación es:" + multiplicacion);
//Método Dividir()
public void Dividir()
int division;
division = valor1 / valor2;
Console.WriteLine("La división es:" + division);
// Main() principal del programa
Operaciones operacion1 = new Operaciones();
operacion1.Inicializar(); // Llamando al método Inicializar();
operacion1.Sumar(); // Llamando al método Sumar();
operacion1.Restar(); // Llamando al método Restar();
operacion1.Multiplicar(); // Llamando al método Multiplicar();

operacion1.Dividir(); // Llamando al método Dividir();
Console.ReadKey();
Arreglos en C#
Arreglos en C#
Los arreglos en C# (también conocidos como Arrays) al igual que en C/C++, son
indexados iniciando en cero (0). La forma de trabajo es muy similar a la mayoría
de lenguajes pero hay lagunas diferencias que notarán.
Como Declarar e Inicializar un Arreglo en C#

Cuando vayamos a declarar un arreglo en debemos colocar los corchetes después
de tipo de dato. En C/C++ se estila poner los corchetes después del identificador,
eso causa un error de compilación en C#-
Declaración de un Arreglo de tipo Vector en C#

//Declaración erronea
int valores[];
//Declaración valida
int[] valores;
En C# podemos indicar el tamaño del arreglo luego de la declaración. Esto nos

permite decidir que tamaño va a tener el arreglo según lo que necesitemos.

int[] valores; //valores sin inicializar
valores = new int[100]; //100 elementos
valores = new int[20]; //ahora contiene 20 elementos
Etiquetas: algoritmo en c#, arreglos en c#, arreglos y vectores en c#, declaración de un vector
en c#, ejercicios con vectores en c#, ejercicios resueltos de vectores en c#, vectores en c#
Ejercicios con Objetos en C#

Ejercicios Resueltos de Objetos en C#
Ejemplo 1
Desarrollar una clase que permita ingresar tres valores por teclado. Luego
mostrar el mayor y el menor.
using System;
using System.Linq;
using System.Text;
namespace EspacioMayorMenor
class MayorMenor
public void cargarValores()
string linea;
int valor1 = int.Parse(linea);
Console.Write("Ingrese segundo numero:");
Console.Write("Ingrese tercer numero:");
int mayor, menor;
mayor = CalcularMayor(valor1, valor2, valor3);

menor = CalcularMenor(valor1, valor2, valor3);
Console.WriteLine("El valor mayor es:" + mayor);
Console.WriteLine("El valor menor es:" + menor);
public int CalcularMayor(int v1, int v2, int v3)
int m;
if (v1 > v2 && v1 > v3)
m = v1;
else
if (v2 > v3)
m = v2;
else
m = v3;
return m;
public int CalcularMenor(int v1, int v2, int v3)
int m;
if (v1 < v2 && v1 < v3)
m = v1;
else
if (v2 < v3)

m = v2;
else
m = v3;
return m;
MayorMenor mm = new MayorMenor();
mm.cargarValores();
Console.ReadKey();
Ejemplo 2
En el ejemplo siguiente, Persona es el tipo y persona1 y persona2 son instancias,

u objetos, de ese tipo.
using System;

using System.Linq;
using System.Text;
namespace clases
class MayorMenor
public class Person
public string Name { get; set; }
public int Age { get; set; }
public Person(string name, int age)
Name = name;
Age = age;
class Program
static void Main()
Person person1 = new Person("Yhonas", 6);
Console.WriteLine("Nombre persona1 = {0} Edad = {1}",

person1.Name, person1.Age);
// Declarar persona nueva, asigne persona1 a ella.
Person person2 = person1;
//Cambiar el nombre de persona2 y persona1 también cambia.
person2.Name = "Elisa";
person2.Age = 16;


// Mantenga la consola abierta en modo de depuración.
Console.WriteLine("Presione enter para continuar");

Console.ReadKey();
Ejercicios Resueltos de Arreglos en C#

Ejercicios Resueltos de Arreglos en C#
Ejemplo 1
Realizar un programa que guardar los sueldos de 5 operarios en un arreglo de

tipo vector
using System;
using System.Linq;
using System.Text;
namespace PruebaVector1
class PruebaVector1
private int[] sueldos; //Declaramos un vector
public void Cargar()
sueldos = new int[6]; //Inicializamos el vector en 5

for (int f = 1; f< = 5; f++)
Console.Write("Ingrese sueldo del operario "+f+": ");
String linea;
sueldos[f] = int.Parse(linea); //Asignamos los 5 sueldos al

vector
//Muestra los sueldos de los operarios en el vector sueldos[f]
Console.Write("Los 5 sueldos de los aperarios \n");
for (int f = 1; f< = 5; f++)
Console.Write("["+sueldos[f]+"] ");
Console.ReadKey();
//main principal
PruebaVector1 pv = new PruebaVector1();
pv.Cargar();
pv.Imprimir();

Para la declaración de un vector le antecedemos al nombre los corchetes

abiertos y cerrados:
private int[] sueldos;
Lo definimos como atributo de la clase ya que lo utilizaremos en los dos métodos.

En el método de Cargar lo primero que hacemos es crear el vector (en C# los
vectores son objetos por lo que es necesario proceder a su creación mediante el
operador new):
sueldos = new int[6];
Ejemplo 2
Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados
(4 por la mañana y 4 por la tarde)
Desarrollar un programa que permita almacenar los sueldos de los empleados
agrupados por turno.
Imprimir los gastos en sueldos de cada turno.
using System;
using System.Linq;
using System.Text;
namespace PruebaVector
class PruebaVector3
private float[] turnoM; //Declaramos un vector para el turno mañana

private float[] turnoT; //Declaramos un vector para el turno tarde
string linea;
turnoM = new float[4]; //Asignamos al vector una de longitud 4
turnoT = new float[4]; //Asignamos al vector una de longitud 4
Console.WriteLine("Sueldos de empleados del turno de la mañana.");
for (int f = 0; f< 4; f++)
Console.Write("Ingrese sueldo "+(f+1)+": ");
turnoM[f] = float.Parse(linea); //Asignamos valores al vector

turno mañana
Console.WriteLine("Sueldos de empleados del turno de la tarde.");
for (int f = 0; f< 4; f++)
Console.Write("Ingrese sueldo "+(f+1)+": ");
turnoT[f] = float.Parse(linea); //Asignamos valores al vector

turno tarde
public void CalcularGastos()
float man = 0;
float tar = 0;
for (int f = 0; f< 4; f++)
man = man + turnoM[f]; //Realizamos la suna de los valores del

vector turno Mañana
tar = tar + turnoT[f]; //Realizamos la suna de los valores del

vector turno Tarde
Console.WriteLine("Total de gastos del turno de la mañana:" + man);
Console.WriteLine("Total de gastos del turno de la tarde:" + tar);

Console.ReadKey();
pv.Cargar();
pv.CalcularGastos();
Etiquetas: arreglos en c#, arreglos y vectores en c#, declaración de un vector en c#, ejercicios
con vectores en c#, ejercicios resueltos de vectores en c#, vectores en c#, Visual Studio
Arreglos Multi-dimensionales en C#
Arreglos Multi-dimensionales
En C# también podemos declarar arreglos multi-dimensionales, aquí unos
ejemplos:
//Arreglos unidimensionales o de dimensión simple

int[] valores1; //sin inicializar
int[] valores2 = new int[50];
//Arreglos multidimensionales
int[,] valores1; //sin inicializar
int[,] valores2 = new int[3,7];
int[,,] valores3 = new int[3,4,2]; //Arreglo de tres dimensiones
//Arreglo de arreglos

int[][] matriz; //sin inicializar
//Los arreglos de arreglos se inicializan de manera diferente
int[][] matriz = new int[3][];
for (int i = 0; i < matriz.Length; i++)
matriz[i] = new int[4];
Ejercicios de Arreglos Multi-dimensionales en C#

Ejercicios de Arreglos Multi-
dimensionales en C#
Realizar un programa que defina un vector de 5 componentes de tipo float que
representen las alturas de 5 personas.
Obtener el promedio de las mismas. Contar cuántas personas son más altas que
el promedio y cuántas más bajas.
using System;
using System.Linq;
using System.Text;
class PruebaVector2
private float[] alturas;
private float promedio;
alturas = new float[5];
for (int f = 0; f< 5; f++)
Console.Write("Ingrese la altura de la persona: "+(f+1)+": ");
string linea = Console.ReadLine();
alturas[f] = float.Parse(linea);

public void CalcularPromedio()
float suma;
suma = 0;
for (int f = 0; f< 5; f++)
suma = suma + alturas[f];
Console.WriteLine("Promedio de alturas es:" + promedio);
public void MayoresMenores()
int may, men;
may = 0;
men = 0;
for (int f = 0; f< 5; f++)
if (alturas[f] > promedio)
may++;
else
if (alturas[f] < promedio)
men++;
Console.WriteLine("Cantidad de personas mayores al promedio:" + may);
Console.WriteLine("Cantidad de personas menores al promedio:" + men);
Console.ReadKey();

PruebaVector2 pv2 = new PruebaVector2();
pv2.Cargar();
pv2.CalcularPromedio();
pv2.MayoresMenores();
Etiquetas: arreglos en c#, arreglos y vectores en c#, declaración de un vector en c#, ejercicios
con vectores en c#, ejercicios resueltos de vectores en c#, vectores en c#, while en c#
Ejercicios Resueltos de Vectores en C#

Ejercicios Resueltos de Vectores en C#
Se tienen las notas del primer parcial de los alumnos de dos cursos, Matemática
y el Física, cada curso cuenta con 5 alumnos.
Realizar un programa que muestre el curso que obtuvo el mayor promedio
general.
using System;
using System.Linq;
using System.Text;
class PruebaVector6

private int[] quimica; //Declaramos un vector para el curso Química
private int[] fisica; //Declaramos un vector para el curso Física
private int[] vecSuma;//Declaramos un vector para la suma
quimica = new int[5]; //Asignamos una longitud de 5 al vector química
fisica = new int[5]; //Asignamos una longitud de 5 al vector Física
Console.WriteLine("Ingrese notas del curso Quimica");
for (int f = 0; f< 5; f++)
Console.Write("Ingrese nota "+(f+1)+": ");
string linea;
quimica[f] = int.Parse(linea);
Console.WriteLine("Ingrese notas del Fisica");
for (int f = 0; f< 5; f++)
Console.Write("Ingrese nota "+(f+1)+": ");
string linea;
fisica[f] = int.Parse(linea);
public void CalcularPromedios()
int suma1 = 0;
int suma2 = 0;
for (int f = 0; f< 5; f++)
suma1 = suma1 + quimica[f];
suma2 = suma2 + fisica[f];

int promedioa = suma1 / 5;
int promediob = suma2 / 5;
if (promedioa > promediob)
Console.WriteLine("El curso de Quimica tiene un promedio

mayor.");
else
Console.WriteLine("El curso de Fisica tiene un promedio mayor.");
Console.ReadKey();
pv.Cargar();
pv.CalcularPromedios();
Suma de vectores en C#
Suma de vectores en C#
Realizar un programa que sume dos vectores y los almacene en un tercer
vector

using System;
using System.Linq;
using System.Text;
class PruebaVector
private int[] A;//Declaramos un vector A
private int[] B;//Declaramos un vector B
private int[] C;//Declaramos un vector C
Console.Write("Ingrese la longitud de los vectores a sumar: ");
string linea;
int n = int.Parse(linea);
A = new int[n];
B = new int[n];
C = new int[n];
Console.WriteLine("Ingresando valores al vector A");
for (int i = 0; i< A.Length; i++)
Console.Write("Ingrese componente [" + ( i + 1 ) +"]: ");
A[i] = int.Parse(linea);
Console.WriteLine("Ingresando valores al vector B");
for (int j = 0; j< B.Length; j++)
Console.Write("Ingrese componente [" + (j + 1) + "]: ");
B[j] = int.Parse(linea);

C[i]=A[i]+B[i];
public void Visualizar()
Console.WriteLine("La suma de los vecores es: ");
Console.Write("["+C[i]+"] ");
Console.ReadLine();
PruebaVector pv = new PruebaVector();
pv.Cargar();
pv.Visualizar();

Etiquetas: arreglos y vectores en c#, ejemplos c#, Ejercicios C#, ejercicios con vectores en
c#,ejercicios resueltos de vectores en c#, suma en c#, sumar dos vectores en c#, vectores en c#
Ejercicios con Vectores en C#

Ejercicios con Vectores en C#
Veamos algunos ejercicios con vectores en c#, que nos ayudaran a entender
mejor el tema acerca de los vectores en c#.
Empezaremos con la búsqueda del mayor y menor elemento de un vector, lo

mismo que su posición.
En la siguiente gráfica se muestra un ejemplo de como un vector almacena datos:
Ejemplo 1
Realizar un programa que permita ingresar los nombres de 5 operarios y sus

sueldos respectivos. Mostrar el sueldo mayor y el nombre del operario.
using System;
using System.Linq;
using System.Text;
class PruebaVector
private string[] nombres; //Declaramos un vector de tipo estring para los

nombres

private float[] sueldos; //Declaramos un vector de tipo float para los

sueldos
nombres = new string[5];
sueldos = new float[5];
for (int f = 0; f< nombres.Length; f++)
Console.Write("Ingrese el nombre del empleado "+(f+1)+": ");
nombres[f] = Console.ReadLine();
Console.Write("Ingrese el sueldo "+(f+1)+": ");
string linea;
sueldos[f] = float.Parse(linea);
public void MayorSueldo()
float mayor;
int pos;
mayor = sueldos[0];
pos = 0;
for (int f = 1; f< nombres.Length; f++)
if (sueldos[f] > mayor)
mayor = sueldos[f];
pos = f;
Console.WriteLine("El empleado con sueldo mayor es :" +

nombres[pos]);
Console.WriteLine("Tiene un sueldo de: " + mayor);
Console.ReadKey();

pv.Cargar();
pv.MayorSueldo();
Ejemplo 2
Realizar un programa que ingrese un vector de n elementos e imprimir el menor

y un mensaje si se repite dentro del vector dicho numero.
using System;
using System.Linq;
using System.Text;

class PruebaVector
private int[] vec;//Declaramos un vector
private int menor;
Console.Write("Ingrese la longitud del vector:");
string linea;
vec = new int[n];
for (int f = 0; f < vec.Length; f++)
Console.Write("Ingrese componente ["+(f+1)+"]: ");
vec[f] = int.Parse(linea);
public void MenorElemento()
menor = vec[0];
for (int f = 1; f< vec.Length; f++)
if (vec[f] < menor)
menor = vec[f];
Console.WriteLine("El elemento menor es: " + menor);
public void RepiteMenor()

int cant = 0;
for (int f = 0; f< vec.Length; f++)
if (vec[f] == menor)
cant++;
if (cant > 1)
Console.WriteLine("Se repite el numero.");
else
Console.WriteLine("No se repite el menor.");
Console.ReadLine();
pv.Cargar();
pv.MenorElemento();
pv.RepiteMenor();

Matrices en C#
Matrices en C#
Este también es un tipo de dato estructurado, que está compuesto por n
dimensiones. Para hacer referencia a cada componente del arreglo es necesario
utilizar n índices, uno para cada dimensión.
Conceptos básicos
Los arreglos multidimensionales tienen más de una dimensión. En C#, las

dimensiones se manejan por medio de un par de corchetes, dentro de los que se
escriben los valores de cada dimensión, separados por comas.
Operaciones.
Para manejar un arreglo, las operaciones a efectuarse son:
 Declaración del arreglo,

 Creación del arreglo,
 Inicialización de los elementos del arreglo,
 Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.

Declaración de Matrices en C#
La sintaxis para declarar un arreglo multidimensional es la siguiente:
<tipo>[ , ...]<identificador >;
Donde:
Tipo indica el tipo correspondiente a los elementos del arreglo,Identificador es el
nombre del arreglo, y el par de corchetes, la coma y las diéresis,[ , ...], representan
las dimensiones del arreglo. Los corchetes encierran todas las comas necesarias
para separar las dimensiones del arreglo.
Ejemplos:
double [ , ] bidim;// Dos dimensiones.

int [ , , ] tridim ;// Tres dimensiones.
char [ , , , ] enciclopedia;// Cuatro dimensiones.

Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se
debe a que, durante dicha operación, no se reserva espacio en la memoria.
Creación
La creación de un arreglo multidimensional consiste en reservar espacioen la
memoria para todos sus elementos, utilizando la siguiente sintaxis:
<identificador > =new<tipo> [dim1, dim2 ... dimN]
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

dim1, dim2 ,dimN son valores enteros que representan las dimensiones del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones
y representa el número de elementos del arreglo.
Veamos la siguiente gráfica donde se muestra una matriz (2x5), en donde se
almacena 5 nombres con sus respectivas edades

Etiquetas: arreglos multidimensionales en c#, c# matrices, c# vectores, ejercicios con matrices
en c#, ejercicios resueltos de matrices en c#, matrices en c#, vectores en c#
Resta de Vectores en C#
Resta de Vectores en C#
Realizar un programa que Reste dos vectores y los almacene en un tercer vector
using System;
using System.Linq;
using System.Text;
{
class PruebaVector
{
private int[] A;//Declaramos un vector A
private int[] B;//Declaramos un vector B
private int[] C;//Declaramos un vector C
{
Console.Write("Ingrese la longitud de los vectores a restar: ");
string linea;
A = new int[n];
B = new int[n];
C = new int[n];
Console.WriteLine("Ingresando valores al vector A");

{
Console.Write("Ingrese componente [" + ( i + 1 ) +"]: ");
A[i] = int.Parse(linea);
}
Console.WriteLine("Ingresando valores al vector B");
for (int j = 0; j< B.Length; j++)
{
Console.Write("Ingrese componente [" + (j + 1) + "]: ");
B[j] = int.Parse(linea);
}
{
C[i]=A[i]-B[i];
}
}
public void Visualizar()
{
Console.WriteLine("La resta de los vecores es: ");
{
Console.Write("["+C[i]+"] ");
}
Console.ReadLine();
}
{
pv.Cargar();
pv.Visualizar();
}
}
}
Ejemplo de Matrices en C#
Ejemplo de Matrices en C#
Realizar un programa que permita imprimir la siguiente serie:

1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1
using System;
using System.Linq;
using System.Text;
class PruebaVector
private int[,] serie;
serie = new int[10,10];
for (int i = 1; i<= 6; i++)
for (int j = 1; j <= 6; j++)
if (i==j)
serie[i, j] = 1;
else
serie[i, j] = 0;

public void visualizar()
for (int i = 1; i< = 6; i++)
for (int j = 1; j <= 6; j++)
Console.Write(serie[i,j]+" ");
Console.ReadKey();
pv.Cargar();
pv.visualizar();
Etiquetas: arreglos multidimensionales en c#, arreglos y vectores en c#, ejemplo con matrices
en c#, ejercicios de matrices en C#, matrices en c#


Ejemplo 1
Desarrollar un programa que permita cargar 5 nombres de personas y sus edades
respectivas. Luego de realizar la carga por teclado de todos los datos imprimir los
nombres de las personas mayores de edad (mayores o iguales a 18 años)
using System;
using System.Linq;
using System.Text;
class PruebaVector
private string[] nombres;
private int[] edades;
nombres = new string[5];
edades = new int[5];
for (int f = 0; f < 5; f++)
Console.Write("Ingrese nombre "+(f+1)+": ");
nombres[f] = Console.ReadLine();
Console.Write("Ingrese edad "+(f+1)+": ");
string linea;
edades[f] = int.Parse(linea);
public void MayoresEdad()
Console.WriteLine("Personas mayores de edad.");
for (int f = 0; f < nombres.Length; f++)

if (edades[f] >= 18)
Console.WriteLine(nombres[f]);
Console.ReadKey();
pv.Cargar();
pv.MayoresEdad();
Ejemplo 2
Realizar un programa que permita imprimir la siguiente serie:
1 0 1 0 1 0
1 0 1 0 1 0

1 0 1 0 1 0
1 0 1 0 1 0
1 0 1 0 1 0
1 0 1 0 1 0
using System;
using System.Linq;
using System.Text;
class PruebaVector
private int[,] serie;
serie = new int[10,10];
for (int i = 1; i<= 6; i++)
for (int j = 1; j <= 6; j++)
if (j % 2 == 0)
serie[i, j] = 0;
else
serie[i, j] = 1;

for (int i = 1; i< = 5; i++)
for (int j = 1; j <= 6; j++)
Console.Write(serie[i,j]+" ");
Console.ReadKey();
pv.Cargar();
pv.visualizar();
Vectores y Matrices en C#
Vectores y Matrices en C#
Un array (matriz o vector) es un conjunto finito y ordenado de elementos
homogéneos. La propiedad “ordenado” significa que el elemento primero, segundo
y tercero,…, enésimo de un array puede ser identificado. Los elementos del array
son homogéneos, es decir, del mismo tipo de datos. Los array también se conocen
como matrices-en matemáticas- y tablas- en cálculos financieros.

En otras palabras un arreglo es una especie de variable que contiene muchos

valores pero cada uno con una posición diferente. Un arreglo puede ser
unidimensional o vectorial, bidimensional o matricial, o multi-dimencional.
Vectores en C#
Qué es un vector? Un vector (o arreglo unidimensional) es una estructura de datos
en la cual se almacena un conjunto de datos de un mismo tipo. Es decir que un
arreglo es una lista de n elementos que posee las siguientes características:
 Se identifica por un único nombre de variable

 Sus elementos se almacenan en posiciones contiguas de memoria
 Se accede a cada uno de sus elementos en forma aleatoria
Matrices en C#

Etiquetas: arreglos y vectores en c#, c# ejercicios resueltos, c# vectores, ejemplo con matrices
en c#, vectores en c#, vectores y matrices en c#
Suma de Matrices en C#
Suma de Matrices en C#
Realizar un programa que permita la suma de dos matrices de 3x3 y el resultado

almacenar en un tercer matriz
using System;
using System.Linq;
using System.Text;
{
class PruebaVector
{
private int[,] MatrizA;
private int[,] MatrizB;
private int[,] MatrizC;
{
MatrizA = new int[10,10];
MatrizB = new int[10, 10];
MatrizC = new int[10, 10];
Console.WriteLine("Ingresando datos al matriz A");
for (int i = 1; i<= 3; i++)
{
for (int j = 1; j <= 3; j++)
{
Console.Write("Ingrese posicion [" + i + "," + j + "]: ");
string linea;
MatrizA[i, j] = int.Parse(linea);
}
}
Console.WriteLine("Ingresando datos al matriz B");
for (int i = 1; i <= 3; i++)
{
for (int j = 1; j <= 3; j++)
{
Console.Write("Ingrese posicion [" + i + "," + j + "]: ");
string linea;
MatrizB[i, j] = int.Parse(linea);
}
}
//Sumamos la matrizA y la MatrizB
for (int i = 1; i< = 3; i++)
{
for (int j = 1; j <= 3; j++)
{
MatrizC[i,j]=MatrizA[i,j]+MatrizB[i,j];
}
}
}
// visualizamos la suma de las matrices
{
Console.WriteLine("La suma de la MatrizA y MatrizB es :");
for (int i = 1; i< = 3; i++)
{
for (int j = 1; j <= 3; j++)
{
Console.Write(MatrizC[i,j]+" ");

}
}
Console.ReadKey();
}
{
pv.Cargar();
pv.visualizar();
}
}
}
Ejemplo de Vectores y Matrices en C#

Ejemplo de Vectores y Matrices en C#
Se desea saber la temperatura media trimestral de cuatro provincias. Para ello se
tiene como dato las temperaturas medias mensuales de dichas provincias.
Se debe ingresar el nombre de la provincia y seguidamente las tres temperaturas
medias mensuales.
Seleccionar las estructuras de datos adecuadas para el almacenamiento de los datos
en memoria.
1. Ingresar por teclado los nombres de las provincias y las temperaturas
medias mensuales.
2. Imprimir los nombres de las provincias y las temperaturas medias
mensuales de las mismas.
3. Calcular la temperatura media trimestral de cada provincia.
4. Imprimir los nombres de las provincias y las temperaturas medias
trimestrales.

5. Imprimir el nombre de la provincia con la temperatura media

trimestral mayor.
using System;
using System.Linq;
using System.Text;
namespace Matriz
{
class Matriz
{
private string[] paises;
private int[,] tempmen;
private int[] temptri;
{
paises = new String[4];
tempmen = new int[4, 3];
for (int f = 0; f< paises.Length; f++)
{
Console.Write("Ingrese el nombre de la provincia "+(f+1)+": ");
paises[f] = Console.ReadLine();
for (int c = 0; c < tempmen.GetLength(1); c++)
{
Console.Write("Ingrese temperatura mensual " + (c + 1) + ":
");
tempmen[f, c] = int.Parse(linea);
}
}
}
public void ImprimirTempMensuales()
{
{
Console.Write("Provincia:" + paises[f] + ":");
{
Console.Write(tempmen[f, c] + " ");
}
}
}
public void CalcularTemperaturaTri()
{
temptri = new int[4];
for (int f = 0; f< tempmen.GetLength(0); f++)
{
int suma = 0;
{
suma = suma + tempmen[f, c];
}
temptri[f] = suma / 3;
}
}
public void ImprimirTempTrimestrales()
{
Console.WriteLine("Temperaturas trimestrales.");

{
Console.WriteLine(paises[f] + " " + temptri[f]);
}
}
public void PaisMayorTemperaturaTri()
{
int may = temptri[0];
string nom = paises[0];
{
if (temptri[f] > may)
{
may = temptri[f];
nom = paises[f];
}
}
Console.WriteLine("Provincia con temperatura trimestral mayor es " +
nom + " que tiene una temperatura de " + may);
}
{
ma.Cargar();
ma.ImprimirTempMensuales();
ma.CalcularTemperaturaTri();
ma.ImprimirTempTrimestrales();
ma.PaisMayorTemperaturaTri();
Console.ReadKey();
}
}
}

Etiquetas: arreglos en c#, arreglos multidimensionales en c#, arreglos y vectores en c#, c#
vectores,ejemplo con matrices en c#, ejercicios de arrays en c#
Ejercicios De Vectores y Matrices en C#

Ejercicios De Vectores y Matrices en C#
Ejercicio
Se tiene la siguiente información:

· Nombres de 4 operarios.
· Ingresos en concepto de sueldo, cobrado por cada operario, en los últimos 3
meses.
Realizar un programa para:
1. Realizar el ingreso de la información mencionada.
2. Generar un vector que contenga el ingreso acumulado en sueldos en
los últimos 3 meses para cada operario.
3. Mostrar por pantalla el total pagado en sueldos a todos los operarios
en los últimos 3 meses
4. Obtener el nombre del operario que tuvo el mayor ingreso acumulado
using System;
using System.Linq;
using System.Text;
namespace Matriz
{
class Matriz
{
private string[] empleados;
private int[,] sueldos;
private int[] sueldostot;
{
empleados = new String[4];
sueldos = new int[4, 3];
for (int f = 0; f< empleados.Length; f++)
{
Console.Write("Ingrese el nombre del operario "+(f+1)+": ");
empleados[f] = Console.ReadLine();
for (int c = 0; c < sueldos.GetLength(1); c++)
{
Console.Write("Ingrese sueldo " + (c + 1) + ": ");
string linea;
sueldos[f, c] = int.Parse(linea);
}
}
}
public void CalcularSumaSueldos()
{
sueldostot = new int[4];
for (int f = 0; f< sueldos.GetLength(0); f++)
{
int suma = 0;
for (int c = 0; c < sueldos.GetLength(1); c++)
{
suma = suma + sueldos[f, c];
}
sueldostot[f] = suma;
}
}
public void ImprimirTotalPagado()
{
Console.WriteLine("Total de sueldos pagados por Operario.");
for (int f = 0; f< sueldostot.Length; f++)
{

Console.WriteLine(empleados[f] + " - " + sueldostot[f]);

}
}
public void EmpleadoMayorSueldo()
{
int may = sueldostot[0];
string nom = empleados[0];
for (int f = 0; f< sueldostot.Length; f++)
{
if (sueldostot[f] > may)
{
may = sueldostot[f];
nom = empleados[f];
}
}
Console.WriteLine("El operario con mayor sueldo es " + nom + " que
tiene un sueldo de " + may);
}
{
ma.Cargar();
ma.CalcularSumaSueldos();
ma.ImprimirTotalPagado();
ma.EmpleadoMayorSueldo();
Console.ReadKey();
}
}
}
Ordenamiento por Inserción Directa en C#

Método de Ordenamiento por Inserción
directa en C#
using System;
using System.Linq;

using System.Text;
class PruebaVector
private int[] vector;
Console.WriteLine("Metodo de insercion directa");
Console.Write("Cuantos longitud del vector:");
string linea;
int cant;
cant = int.Parse(linea);
vector = new int[cant];
for (int f = 0; f < vector.Length; f++)
Console.Write("Ingrese elemento "+(f+1)+": ");
vector[f] = int.Parse(linea);
public void InsercionDirecta()
int auxili;
int j;
for (int i = 0; i < vector.Length; i++)
auxili = vector[i];
j = i - 1;
while (j >= 0 && vector[j] > auxili)
vector[j + 1] = vector[j];
j--;

vector[j + 1] = auxili;
Console.WriteLine("Vector ordenados en forma ascendente");
Console.Write(vector[f]+" ");
Console.ReadKey();
pv.Cargar();
pv.InsercionDirecta();
pv.Imprimir();
Etiquetas: burbuja en c#, ejercicios con métodos de ordenamiento en c#, inserción binaria en
C#,inserción directa en c#, merge sort en c#, quick sort en c#, shaker sort en c#, shell sor en c#

Métodos de Ordenamiento en C#
Métodos de Ordenamiento en C#
En computación un algoritmo de ordenamiento es un algoritmo que pone
elementos de una lista o un vector en una secuencia dada por una relación de
orden, es decir, el resultado de salida ha de ser una permutación o
reordenamiento de la entrada que satisfaga la relación de orden dada. Las
relaciones de orden más usadas son el orden numérico y el orden lexicográfico.
Ordenamientos eficientes son importantes para optimizar el uso de otros
algoritmos (como los de búsqueda y fusión) que requieren listas ordenadas para
una ejecución rápida.
Ahora veremos los distintos métodos de ordenamiento en c#, aremos un

ejemplo de cada uno de los métodos de ordenamiento.
Ejemplo
using System;
using System.Linq;
using System.Text;
class PruebaVector
string linea;
int cant;

int auxili;
int j;
auxili = vector[i];
j = i - 1;
j--;
Console.ReadKey();
pv.Cargar();

pv.Imprimir();
Ordenamiento por Shell Sort en C#

Método de Ordenamiento Shell Sort en C#
using System;
using System.Linq;
using System.Text;
class PruebaVector
Console.WriteLine("Metodo de Shell Sort");
string linea;
int cant;

public void Shell()
int salto = 0;
int sw = 0;
int auxi = 0;
int e = 0;
salto = vector.Length / 2;
while (salto > 0)
sw = 1;
while (sw != 0)
sw = 0;
e = 1;
while (e <= (vector.Length - salto))
if (vector[e - 1] > vector[(e - 1) + salto])
auxi = vector[(e - 1) + salto];
vector[(e - 1) + salto] = vector[e - 1];
vector[(e - 1)] = auxi;
sw = 1;
e++;
salto = salto / 2;

Console.ReadKey();
pv.Cargar();
pv.Shell();
pv.Imprimir();
Ordenamiento por Inserción Binaria en C#

Método de Ordenamiento por Inserción

Binaria en C#
int auxiliar;
int q;
int izqui;
int dere;
for (int i = 0; i < numeros.Length; i++)
auxiliar = numeros[i];
izqui = 0;
dere = i - 1;
while (izqui <= dere)
q = ((izqui + dere) / 2);
if (auxiliar < numeros[q])
dere = q - 1;
else
izqui = q + 1;
j = i - 1;
while (j >= izqui)
numeros[j + 1] = numeros[j];
j = j - 1;
numeros[izqui] = auxiliar;
for (int i = 0; i < longitud; i++)
Console.WriteLine(" " + numeros[i]);

Ordenamiento por Burbuja en C#

Método de Ordenamiento Burbuja en C#
using System;
using System.Linq;
using System.Text;
namespace Burbuja
{
class Burbuja
Console.WriteLine("Metodo de Burbuja");
Console.Write("Cuantos longitud del vector: ");
string linea;
int cant;
public void MetodoBurbuja()
int t;
for (int a = 1; a< vector.Length; a++)
for (int b = vector.Length - 1; b >= a; b--)

if (vector[b - 1] > vector[b])
t = vector[b - 1];
vector[b - 1] = vector[b];
vector[b] = t;
for (int f = 0; f< vector.Length; f++)
Console.ReadKey();
Burbuja pv = new Burbuja();
pv.Cargar();
pv.MetodoBurbuja();
pv.Imprimir();

Ordenamiento por Quick Sort en C#

Método de Ordenamiento Quick Sort en
C#
using System;
using System.Linq;
using System.Text;
namespace quicksort
{
class Class
static void Main()
int n;
Console.WriteLine("Metodo de Quick Sort");
n = Int32.Parse(Console.ReadLine());
llenar b = new llenar(n);
class llenar
int h;

int[] vector;
public llenar(int n)
h = n;
vector = new int[h];
for (int i = 0; i < h; i++)
Console.Write("ingrese valor {0}: ", i + 1);
vector[i] = Int32.Parse(Console.ReadLine());
quicksort(vector, 0, h - 1);
mostrar();
private void quicksort(int[] vector, int primero, int ultimo)
int i, j, central;
double pivote;
central = (primero + ultimo) / 2;
pivote = vector[central];
i = primero;
j = ultimo;
do
while (vector[i] < pivote) i++;
while (vector[j] > pivote) j--;
if (i <= j)
int temp;
temp = vector[i];
vector[i] = vector[j];
vector[j] = temp;
i++;
j--;

} while (i <= j);
if (primero < j)
quicksort(vector, primero, j);
if (i < ultimo)
quicksort(vector, i, ultimo);
private void mostrar()
for (int i = 0; i < h; i++)
Console.Write("{0} ", vector[i]);
Console.ReadLine();
Ordenamiento por Merge Sort en C#

Método de Ordenamiento Merge Sort en

C#
using System;
using System.Linq;
using System.Text;
namespace MergeSort
class Program
int[] nums = new int[40];
Console.WriteLine("Metodo de Merge Sort");
string linea;
int cant;
nums = new int[cant];
for (int f = 0; f< nums.Length; f++)
Console.Write("Ingrese elemento " + (f + 1) + ": ");
nums[f] = int.Parse(linea);
MergeSort(nums);
Console.WriteLine("Vector Ordenado Ascendentemente");
for (int i = 0; i< nums.Length; i++)
Console.Write(nums[i] + " ");
Console.ReadLine();
//Método portal que llama al método recursivo inicial

public static void MergeSort(int[] x)
MergeSort(x, 0, x.Length - 1);
static private void MergeSort(int[] x, int desde, int hasta)
//Condicion de parada
if (desde == hasta)
return;
//Calculo la mitad del array
int mitad = (desde + hasta) / 2;
//Voy a ordenar recursivamente la primera mitad
//y luego la segunda
MergeSort(x, desde, mitad);
MergeSort(x, mitad + 1, hasta);
//Mezclo las dos mitades ordenadas
int[] aux = Merge(x, desde, mitad, mitad + 1, hasta);
Array.Copy(aux, 0, x, desde, aux.Length);
//Método que mezcla las dos mitades ordenadas
static private int[] Merge(int[]

x, int desde1, int hasta1, int desde2, inthasta2)
int a = desde1;
int b = desde2;
int[] result = new int[hasta1 - desde1 + hasta2 - desde2 + 2];
for (int i = 0; i< result.Length; i++)
if (b != x.Length)
if (a > hasta1 && b <= hasta2)
result[i] = x[b];
b++;

if (b > hasta2 && a <= hasta1)
result[i] = x[a];
a++;
if (a <= hasta1 && b <= hasta2)
if (x[b] <= x[a])
result[i] = x[b];
b++;
else
result[i] = x[a];
a++;
else
if (a <= hasta1)
result[i] = x[a];
a++;
return result;

Ordenamiento por Shaker Sort en C#

Método de Ordenamiento Shaker Sort en
C#
int n = numeros.Length;
int izq = 1;
int k = n;
int aux;
int der = n;
do
for (int i = der; i >= izq; i--)
if (numeros[i - 1] > numeros[i])
aux = numeros[i - 1];
numeros[i - 1] = numeros[i];
numeros[i] = aux;
k = i;

izq = k + 1;
for (int i = izq; i <= der; i++)
if (numeros[i - 1] > numeros[i])
aux = numeros[i - 1];
numeros[i - 1] = numeros[i];
numeros[i] = aux;
k = 1;
der = k - 1;
while (der >= izq);
Ejercicios Resueltos de Arrays en C#

Ejercicios Resueltos de Arrays en C#
Ejemplo 2
Definir un vector donde almacenar los nombres de 5 personas. Realizar un

programa que ordene alfabéticamente
using System;
using System.Linq;
using System.Text;

class PruebaVector
private string[] nombre;
nombre = new string[5];
for (int f = 0; f < nombre.Length; f++)
Console.Write("Ingrese el nombre "+(f+1)+": ");
nombre[f] = Console.ReadLine();
public void Ordenar()
for (int k = 0; k < 4; k++)
for (int f = 0; f < 4 - k; f++)
if (nombre[f].CompareTo(nombre[f + 1]) > 0)
string aux;
aux = nombre[f];
nombre[f] = nombre[f + 1];
nombre[f + 1] = aux;
Console.WriteLine("Los nombres ordenados en forma alfabéticamente");
for (int f = 0; f < nombre.Length; f++)
Console.WriteLine(nombre[f]);

Console.ReadKey();
pv.Cargar();
pv.Ordenar();
pv.Imprimir();
Ejemplo 3
Ingresar un vector de n elementos de tipo entero. Ordenar posteriormente el

vector en forma ascendente
using System;
using System.Linq;

using System.Text;
class PruebaVector
string linea;
int cant;
for (int k = 0; k < vector.Length; k++)
for (int f = 0; f < vector.Length - 1 - k; f++)
if (vector[f] > vector[f + 1])
int aux;
aux = vector[f];
vector[f] = vector[f + 1];
vector[f + 1] = aux;

Console.ReadKey();
pv.Cargar();
pv.Ordenar();
pv.Imprimir();
Etiquetas: c sharp, ejercicios de métodos de ordenamiento en c#, métodos de ordenamiento

en c#,ordenar en c#, ordenar vectores en c#

Ordenar Vectores en C#
Ordenar Vectores en C#
El ordenamiento de un vector se logra intercambiando las componentes de
manera que:
vec[0] <= vec[1] <= vec[2] ..<=vec[n]
El contenido de la componente vec[0] sea menor o igual al contenido de la
componente vec[1] y así sucesivamente.
Si se cumple lo dicho anteriormente decimos que el vector está ordenado de
menor a mayor. Igualmente podemos ordenar un vector de mayor a menor.
Se puede ordenar tanto vectores con componentes de tipo int, float como string.
En este último caso el ordenamiento es alfabético.
Veamos algunos ejemplos de ordenamiento de vectores, ya que podemos
ordenar ascendente o decentemente los valores de un vector.
Ejercicios de Ordenamiento en C#
Ejemplo 1
Realizar un programa que dado un vector y que almacene 5 números para luego
ordenar los números acendentemente.
using System;
using System.Linq;
using System.Text;
class PruebaVector
private int[] numeros;
numeros = new int[5];
for (int f = 0; f < numeros.Length; f++)
Console.Write("Ingrese numero "+(f+1)+": ");

numeros[f] = int.Parse(linea);
for (int k = 0; k < 4; k++)
for (int f = 0; f < 4 - k; f++)
if (numeros[f] > numeros[f + 1])
int aux;
aux = numeros[f];
numeros[f] = numeros[f + 1];
numeros[f + 1] = aux;
Console.WriteLine("Ordenado Ascendentemante");
for (int f = 0; f < numeros.Length; f++)
Console.Write(numeros[f]+" ");
Console.ReadKey();
pv.Cargar();
pv.Ordenar();

pv.Imprimir();
Método de Ordenamiento de Inserción Binaria en C#

Método de Ordenamiento de Inserción
Binaria en C#
La Inserción Binaria, es una mejora de la Inserción Directa.
La Inserción Binaria es un método de inserción, que difiere de la Inserción Directa
simplemente en la búsqueda de la posición de la Inserción.
Veamos un ejemplo de como funciona este método de ordenamiento de
Inserción Binaria, analizando paso a paso.
1. Hallamos el elemento central del área comprendida por la parte ordenada más
la posición del elemento a insertar.

2. Comparamos el elemento central con el elemento que queremos insertar. Si

dicho elemento central es menor o igual, nos quedamos con la parte derecha (Sin
incluir el elemento central). En caso contrario, nos quedamos con la parte
izquierda incluyendo al elemento central.
3. Repetimos el mismo proceso sobre el área con la que nos quedamos, hasta
que dicha área sea nula.
4. Cuando el área sea nula, tendremos la posición de inserción.

A continuación veamos un ejemplo en Pseudo-Código Para el Método de

Inserción Binaria
Ejemplo del Código Implementado

Un ejemplo de método de inserción binaria en C#

int auxiliar;
int q;
int izqui;
int dere;
for (int i = 0; i < numeros.Length; i++)
auxiliar = numeros[i];
izqui = 0;
dere = i - 1;
while (izqui <= dere)
q = ((izqui + dere) / 2);
if (auxiliar < numeros[q])
dere = q - 1;
else
izqui = q + 1;

j = i - 1;
while (j >= izqui)
numeros[j + 1] = numeros[j];
j = j - 1;
numeros[izqui] = auxiliar;
Etiquetas: c# métodos de ordenamiento, ejemplo de inserción binaria en C#, inserción binaria

en C#, método de ordenamiento de inserción binaria en C#, métodos de ordenamiento en c#
Método de Ordenamiento de Inserción Directa en C#

Método de Ordenamiento de Inserción
Directa en C#
El método de inserción directa es el que generalmente utilizan los jugadores de
cartas cuando ordenan éstas, de ahí que también se conozca con el nombre de
método de la baraja.
La idea central de este algoritmo consiste en insertar un elemento del arreglo en
la parte izquierda del mismo, que ya se encuentra ordenada. Este proceso se
repite desde el segundo hasta el n-esimo elemento.
Ejemplo:
Se desean ordenarse las siguientes clave del arreglo A: 15, 67, 08, 16, 44, 27, 12,
35
Primera pasada
A[2] < A[1] 67 < 15 No hay intercambio
A: 15, 67, 08, 16, 44, 27, 12, 35

Segunda pasada
A[3] < A[2] 08 < 67 Si hay intercambio
A[2] < A[1] 08 < 15 Si hay
A: 15, 08, 67, 16, 44, 27, 12, 35

Tercera pasada
A= 08, 15, 67, 16, 44, 27, 12, 35

Hasta la séptima pasada el arreglo queda ordenado: 08, 12, 15, 16, 27, 35, 44,
67
A continuación veamos un ejemplo en Pseudo-Código Para el Método de Shell

Sort
void InsercionDirecta (int arreglo[], int tam)

{
int i , j , valorBusqueda;
for(i = 1; i < tam; i++)
{
valorBusqueda = a[i];
for (j = i - 1; j >= 0 && a[j] > valorBusqueda; j--)
{
a[j + 1] = a[j];
}
a[j + 1] = valorBusqueda;
}
val = a[i];
}
Ejemplo del Método de Ordenamiento Inserción Directa en c#
using System;

using System.Linq;
using System.Text;
class PruebaVector
string linea;
int cant;
int auxili;
int j;
auxili = vector[i];
j = i - 1;

j--;
Console.ReadKey();
pv.Cargar();
pv.Imprimir();
Método de Ordenamiento Quick Sort en C#

Método de Ordenamiento Quick Sort en

C#
El método de ordenamiento Quick Sort es actualmente el más eficiente y veloz de
los métodos de ordenación interna. Es también conocido con el nombre del método
rápido y de ordenamiento por partición, en el mundo de habla hispana.
Este método es una mejora sustancial del método de intercambio directo y recibe
el nombre de Quick Sort por la velocidad con que ordena los elementos del arreglo.
Su autor C.A. Hoare lo bautizó así.
La idea central de este algoritmo consiste en los siguiente:
 Se toma un elemento x de una posición cualquiera del arreglo.

 Se trata de ubicar a x en la posición correcta del arreglo, de tal forma que
todos los elementos que se encuentran a su izquierda sean menores o iguales a x y
todos los elementos que se encuentren a su derecha sean mayores o iguales a x.
 Se repiten los pasos anteriores pero ahora para los conjuntos de datos que
se encuentran a la izquierda y a la derecha de la posición correcta de x en el arreglo.
Ejemplo:
A: 15,67,08,16,44,27,12,35
Se selecciona A[i] x=15
Primera pasada (DER-IZQ)

A[8] >= x 35 >= 15 No hay intercambio
A[7] >= x 12 >= 15 Si hay intercambio
A: 12,67,08,16,44,27,15,35
(IZQ-DER)
A[2] < = X 67 < = 15 Si hay intercambio
A:12,15,08,16,44,27,67,35
2da. Pasada (DER-IZQ)

A[3] >= x 08 >= 15 Si hay intercambio
A: 12,08,15,16,44,27,67,35
Como el recorrido de izquierda a derecha debería iniciarse en la misma

posición donde se encuentra el elemento x, el proceso se termina ya que el
elemento x, se encuentra en la posición correcta.
A: 12, 08, 15, 16, 44, 27, 67, 35
1er 2do Conjunto

16, 44, 27, 67, 35
x16
(DER-IZQ)
A[8]>=x No hay intercambio
A: 12, 08, 15, 16, 44, 27, 67, 35
xß44
(DER-IZQ)
A[8]>= x Si hay intercambio
A: 12, 08, 15, 16, 35, 27, 67, 44
(IZQ-DER)
A[6] < = x No hay intercambio
A[7] < = x Si hay intercambio
12, 08, 15, 16, 35, 27, 44, 67
12, 08, 15, 16, 35, 27, 44, 67
35, 27, 44, 67
xß35
(DER-IZQ)
A[8] >= x No hay intercambio
A[7] >= x No hay intercambio
A[6] >= x Si hay intercambio
12, 08, 15, 16, 27, 35, 44, 67
12,08
xß12
(DER-IZQ)
A[2]>=x Si hay intercambio
EL VECTOR ORDENADO:
08,12,15,16,27,35,44,67
A continuación veamos un ejemplo en Pseudo-Código Para el Método de Quick

Sort

Ejemplo del Método de Ordenamiento Quick Sort en C#

using System;
using System.Linq;
using System.Text;
namespace quicksort
{
class Class
{
static void Main()
{
int n;
Console.WriteLine("Metodo de Quick Sort");
n = Int32.Parse(Console.ReadLine());
llenar b = new llenar(n);
}
}
class llenar
{
int h;
int[] vector;
public llenar(int n)
{
h = n;
vector = new int[h];
for (int i = 0; i < h; i++)
{
Console.Write("ingrese valor {0}: ", i + 1);

vector[i] = Int32.Parse(Console.ReadLine());
}
quicksort(vector, 0, h - 1);
mostrar();
}
private void quicksort(int[] vector, int primero, int ultimo)
{
int i, j, central;
double pivote;
central = (primero + ultimo) / 2;
pivote = vector[central];
i = primero;
j = ultimo;
do
{
while (vector[i] < pivote) i++;
while (vector[j] > pivote) j--;
if (i <= j)
{
int temp;
temp = vector[i];
vector[i] = vector[j];
vector[j] = temp;
i++;
j--;
}
} while (i <= j);
if (primero < j)
{
quicksort(vector, primero, j);
}
if (i < ultimo)
{
quicksort(vector, i, ultimo);
}
}
private void mostrar()
{
for (int i = 0; i < h; i++)
{
Console.Write("{0} ", vector[i]);
}
Console.ReadLine();
}
}
}


Etiquetas: c# métodos de ordenamiento, ejemplo de quick sort en c#, método de ordenamiento
quick sort en c#, ordenación rápida en c#, quick sort, quick sort en c#
Método de Ordenamiento Shell Sort en C#

Es un algoritmo de ordenación interna muy sencillo pero muy ingenioso, basado
en comparaciones e intercambios, y con unos resultados radicalmente mejores que
los que se pueden obtener con el método de la burbuja, el des elección directa o el
de inserción directa.
Sin embargo, es necesario romper una lanza a favor del algoritmo ShellSort, ya
que es el mejor algoritmo de ordenación in-situ... es decir, el mejor de aquellos en
los que la cantidad de memoria adicional que necesita -aparte de los propios datos
a ordenar, claro está- es constante, sea cual sea la cantidad de datos a ordenar. El
algoritmo de la burbuja, el de selección directa, el de inserción directa y el de Shell
son todos in-situ, y éste último, el de Shell, es el que mejor resultados da, sin
ninguna duda de todos ellos y sus posibles variantes.
El ShellSort es una mejora del método de inserción directa que se utiliza cuando
el número de elementos a ordenar es grande. El método se denomina “shell” –en
honor de su inventor Donald Shell – y también método de inserción con
incrementos decrecientes.
En el método de clasificación por inserción, cada elemento se compara con los
elementos contiguos de su izquierda, uno tras otro. Si el elemento a insertar es más
pequeño - por ejemplo -, hay que ejecutar muchas comparaciones antes de
colocarlo en su lugar definitivamente. Shell modifico los saltos contiguos
resultantes de las comparaciones por saltos de mayor tamaño y con eso se
conseguía la clasificación más rápida. El método se basa en fijar el tamaño de los
saltos constantes, pero de más de una posición.
Considere un valor pequeño que está inicialmente almacenado en el final del

vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el
ordenamiento por inserción, tomará aproximadamente n comparaciones e
intercambios para mover este valor hacia el otro extremo del vector. El Shell sort
primero mueve los valores usando tamaños de espacio gigantes, de manera que un
valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo
unas pocas comparaciones e intercambios.

Uno puede visualizar el algoritmo Shell sort de la siguiente manera: coloque la

lista en una tabla y ordene las columnas (usando un ordenamiento por inserción).
Repita este proceso, cada vez con un número menor de columnas más largas. Al
final, la tabla tiene sólo una columna.
Mientras que transformar la lista en una tabla hace más fácil visualizarlo, el
algoritmo propiamente hace su ordenamiento en contexto (incrementando el índice
por el tamaño de paso, esto es usando i += tamaño_de_paso en vez de i++).
Por ejemplo, considere una lista de números como [ 13 14 94 33 82 25 59 94 65

23 45 27 73 25 39 10 ]. Si comenzamos con un tamaño de paso de 8, podríamos
visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto
quedaría así:
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
Entonces ordenamos cada columna, lo que nos da:
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
Cuando lo leemos de nuevo como una única lista de números, obtenemos:
[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]
Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial.

Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio
de 3 posiciones, y después un ordenamiento con un espacio de 1 posición
(ordenamiento por inserción simple).
El Shell sort lleva este nombre en honor a su inventor, Donald Shell, que lo publicó
en 1959. Algunos libros de texto y referencias antiguas le llaman ordenación
"Shell-Metzner" por Marlene Metzner Norton, pero según Metzner, "No tengo
nada que ver con el algoritmo de ordenamiento, y mi nombre nunca debe
adjuntarse a éste."
A continuación veamos un ejemplo en Pseudo-Código Para el Método de Shell

Sort

Ejemplo del Método de Ordenamiento Shell Sort en C#

using System;
using System.Linq;
using System.Text;
{
class PruebaVector
{
{
Console.WriteLine("Metodo de Shell Sort");
string linea;
int cant;
{
}
}
public void Shell()
{
int salto = 0;
int sw = 0;
int auxi = 0;
int e = 0;
salto = vector.Length / 2;
while (salto > 0)
{
sw = 1;

while (sw != 0)
{
sw = 0;
e = 1;
while (e <= (vector.Length - salto))
{
if (vector[e - 1] > vector[(e - 1) + salto])
{
auxi = vector[(e - 1) + salto];
vector[(e - 1) + salto] = vector[e - 1];
vector[(e - 1)] = auxi;
sw = 1;
}
e++;
}
}
salto = salto / 2;
}
}
{
{
}
Console.ReadKey();
}
{
pv.Cargar();
pv.Shell();
pv.Imprimir();
}
}
}
Método de Ordenamiento Merge Sort en C#

Método de Ordenamiento Merge Sort en
C#

Esta vez estaremos hablando de Ordenación por Mezcla (Merge Sort), otro
algoritmo recursivo bastante eficiente para ordenar un array, que tiene un orden de
complejidad O(nlogn) al igual que Quick Sort. Fue desarrollado en 1945 por John
Von Neumann según wikipedia.
Estrategia de Merge Sort
Merge Sort está basado en la técnica de diseño de algoritmos Divide y Vencerás,
de la cual se habló aquí mismo hace un tiempo. Recordando un poco, esta técnica
consiste en dividir el problema a resolver en sub problemas del mismo tipo que a
su vez se dividirán, mientras no sean suficientemente pequeños o triviales.
Veamos una panorámica de la estrategia que sigue este algoritmo para ordenar una
secuencia S de n elementos:
 Si S tiene uno o ningún elemento, está ordenada

 Si S tiene al menos dos elementos se divide en dos secuencias S1 y S2
 S1 contiene los primeros n/2 elementos y S2 los restantes
 Ordenar S1 y S2, aplicando recursivamente este procedimiento
 Mezclar S1 y S2 en S, de forma que ya S1 y S2 estén ordenados
 Veamos ahora como sería la estrategia para mezclar las secuencias:
Se tienen referencias al principio de cada una de las secuencias a mezclar (S1 y

S2). Mientras en alguna secuencia queden elementos, se inserta en la secuencia
resultante (S) el menor de los elementos referenciados y se avanza esa referencia
una posición.
Pseudocódigo del Método de Ordenamiento Merge Sort
Como ven, la idea es bastante simple, pero programarla no tanto. Para no dar de
golpe la solución, veamos primero un pseudocódigo del algoritmo:
function mergesort(array A[x..y])
begin
if (x-y > 1)):
array A1 := mergesort(A[x..(int( x+y / 2))])
array A2 := mergesort(A[int(1+(x+y / 2))..y])
return merge(A1, A2)

else:
return A
end
function merge(array A1[0..n1], array A2[0..n2])
begin
integer p1 := 0
integer p2 := 0
array R[0..(n1 + n2 + 2)]//suponiendo que n1 y n2 son las posiciones
//del array y no el length de este mismo, de otro modo seria (n1 + n2)
while (p1 <= n1 or p2 <= n2):
if (p1 <= n1 and A1[p1] <= A2[p2]):
R[p1 + p2] := A1[p1]
p1 := p1 + 1
else
if (p2 <= n2 and A1[p1] > A2[p2]):
R[p1 + p2] := A2[p2]
p2 := p2 + 1
return R
end
Ejemplo del Método de Ordenamiento Merge Sort en C#
using System;
using System.Linq;
using System.Text;
namespace MergeSort
{
class Program
{
{
int[] nums = new int[40];
Console.WriteLine("Metodo de Merge Sort");
string linea;
int cant;
nums = new int[cant];
for (int f = 0; f < nums.Length; f++)
{
nums[f] = int.Parse(linea);
}
MergeSort(nums);
Console.WriteLine("Vector Ordenado Ascendentemente");
for (int i = 0; i < nums.Length; i++)
Console.Write(nums[i] + " ");
Console.ReadLine();
}
//Método portal que llama al método recursivo inicial
public static void MergeSort(int[] x)

{
MergeSort(x, 0, x.Length - 1);
}
static private void MergeSort(int[] x, int desde, int hasta)
{
//Condicion de parada
if (desde == hasta)
return;
//Calculo la mitad del array
int mitad = (desde + hasta) / 2;
//Voy a ordenar recursivamente la primera mitad
//y luego la segunda
MergeSort(x, desde, mitad);
MergeSort(x, mitad + 1, hasta);
//Mezclo las dos mitades ordenadas
int[] aux = Merge(x, desde, mitad, mitad + 1, hasta);
Array.Copy(aux, 0, x, desde, aux.Length);
}
//Método que mezcla las dos mitades ordenadas
static private int[] Merge(int[]
x, int desde1, int hasta1, int desde2, int hasta2)
{
int a = desde1;
int b = desde2;
int[] result = new int[hasta1 - desde1 + hasta2 - desde2 + 2];
for (int i = 0; i < result.Length; i++)
{
if (b != x.Length)
{
if (a > hasta1 && b <= hasta2)
{
result[i] = x[b];
b++;
}
if (b > hasta2&& a <= hasta1)
{
result[i] = x[a];
a++;
}
if (a <= hasta1&& b <= hasta2)
{
if (x[b] <= x[a])
{
result[i] = x[b];
b++;
}
else
{
result[i] = x[a];
a++;
}
}
}
else
{
if (a <= hasta1)
{
result[i] = x[a];
a++;
}
}

}
return result;
}
}
}

Etiquetas: arreglos en c#, bucle for, c# merge sort, ejemplo del merge sort en c#, merge sort en
c#,método de ordenamiento de merge sort en c#, métodos de ordenamiento en c#, mezcla en c#

Este método consiste en ir comparando cada par de elementos del array e ir
moviendo el mayor elemento hasta la última posición, comenzando desde la
posición cero. Una vez acomodado el mayor elemento, prosigue a encontrar y
acomodar el segundo más grande comparando de nuevo los elementos desde el
inicio de la lista, y así sigue hasta ordenar todos los elementos del arreglo. Al ser
necesario revisar varias veces toda la lista hasta que no se necesiten más
intercambios, hace que el ordenamiento por burbuja sea uno de los algoritmos más
ineficientes que existen. Incluso entre los algoritmos de ordenamiento del mismo
orden, otros como el “Ordenamiento por inserción” son considerados más
eficientes. Y lo más curioso es que este procedimiento es uno de los más usados
para ordenar listas en todos los lenguajes de programación.
Estos serían los pasos a seguir por este algoritmo para ordenar una lista a1, a2, a3,
… an
1) Comparar a1 con a2 e intercambiarlos si a1>a2
2) Seguir hasta que se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces
Ejemplo:
25 57 48 37 12 92 86 33
En el primer paso se realizan las siguientes operaciones:
x[0] con x[1] (25 con 57) no intercambio.
x[1] con x[2] (57 con 48) intercambio.


x[4] con x[5] (57 con 92) no intercambio.
Así después del primer paso, el arreglo está en el siguiente orden:
25 48 37 12 57 86 33 92
Observe que después del primer paso, el elemento mayor (en este caso 92) está en
la posición correcta dentro del arreglo. En general x[n-i] estará en su posición
correcta después de la iteración i. El método se lama ordenamiento de burbuja
porque cada número “burbujea” con lentitud hacia su posición correcta. El
conjunto completo de iteraciones es:
iteración 0 : 25 57 48 37 12 92 86 33
iteración 1: 25 48 37 12 57 86 33 92
iteración 2: 25 37 12 48 57 33 86 92
iteración 3: 25 12 37 48 33 57 86 92
iteración 4: 12 25 37 33 48 57 89 92
iteración 5: 12 25 33 37 48 57 89 92
A continuación veamos un ejemplo en Pseudo-Código Para el Método

Burbuja

Ejemplo del Método de Ordenamiento Burbuja en C#

using System;
using System.Linq;
using System.Text;
namespace Burbuja
{
class Burbuja
{
{
Console.WriteLine("Metodo de Burbuja");
string linea;
int cant;


{
}
}
public void MetodoBurbuja()
{
int t;
for (int a = 1; a < vector.Length; a++)
for (int b = vector.Length - 1; b >= a; b--)
{
if (vector[b - 1] > vector[b])
{
t = vector[b - 1];
vector[b - 1] = vector[b];
vector[b] = t;
}
}
}
{
{
}
Console.ReadKey();
}
{
Burbuja pv = new Burbuja();
pv.Cargar();
pv.MetodoBurbuja();
pv.Imprimir();
}
}
}


Ejemplo 1
Crear una matriz de 3 filas por 4 columnas con elementos de tipo int, ingresar
sus posiciones y luego imprimirlas.
using System;
using System.Linq;
using System.Text;
namespace Matriz
class Matriz
private int[,] mat;
public void Ingresar()
for (int f = 0; f < 3; f++)
for (int c = 0; c < 4; c++)
string linea;
for (int f = 0; f < 3; f++)
for (int c = 0; c < 4; c++)

Console.Write(mat[f, c] + " ");
Console.ReadKey();
ma.Ingresar();
ma.Imprimir();
Ejemplo 2

Crear una matriz de 3 filas por 4 columnas e ingresar valores enteros, imprimir
la primer fila. Imprimir la última fila e imprimir la primer columna
using System;
using System.Linq;
using System.Text;
namespace Matriz
class Matriz
private int[,] mat;
for (int f = 0; f < 3; f++)
for (int c = 0; c < 4; c++)
string linea;
public void PrimerFila()
Console.WriteLine("\nPrimer fila de la matriz:");
for (int c = 0; c< 4; c++)

Console.Write(mat[0, c]+" ");
public void UltimaFila()
Console.WriteLine("\nUltima fila de la matriz:");
for (int c = 0; c< 4; c++)
Console.Write(mat[2, c]+" ");
public void PrimerColumna()
Console.WriteLine("\nPrimer columna:");
for (int f = 0; f< 3; f++)
Console.Write(mat[f, 0]+" ");
ma.Cargar();
ma.PrimerFila();
ma.UltimaFila();
ma.PrimerColumna();
Console.ReadKey();

Etiquetas: arreglos y vectores en c#, c# matrices, ejemplo de matrices en c#, ejercicios

resueltos de matrices en c#, estructura anidada en c#, Estructura repetitiva For en C#, matrices
en c#
Matrices en C Sharp
Una matriz es una estructura de datos que permite almacenar un conjunto de
datos del mismo tipo.
Con un único nombre se define la matriz y por medio de DOS sub índices hacemos
referencia a cada elemento de la misma (componente)
Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada
elemento debemos indicar primero la fila y luego la columna, por ejemplo en la
componente 1,4 se almacena el valor 97.

En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz

deben ser del mismo tipo (int, float, string etc.)
Las filas y columnas comienzan a numerarse a partir de cero, similar a los
vectores.
Declaración de una Matriz en C#

C# admite matrices de una dimensión, matrices multidimensionales (matrices
rectangulares) y matrices de matrices (matrices escalonadas). El siguiente
ejemplo muestra cómo declarar diferentes tipos de matrices:
int[] numbers;
Matrices multidimensionales:
string[,] names;
Matrices de matrices (escalonadas):

byte[][] scores;
La declaración de matrices (como se muestra arriba) no crea realmente las

matrices. En C#, las matrices son objetos (se explica más adelante en este
tutorial) cuyas instancias deben crearse. Los siguientes ejemplos muestran
cómo crear matrices:
int[] numbers = new int[5];
Matrices multidimensionales:
string[,] names = new string[5,4];
Matrices de matrices (escalonadas):

byte[][] scores = new byte[5][];

for (int x = 0; x < scores.Length; x++)

{
scores[x] = new byte[4];
}
También se pueden utilizar matrices más grandes. Por ejemplo, se puede utilizar
una matriz rectangular de tres dimensiones:
int[,,] buttons = new int[4,5,3];
Incluso, se pueden combinar matrices rectangulares y escalonadas. Por ejemplo,

el siguiente código declara una matriz unidimensional que contiene matrices
tridimensionales de matrices bidimensionales de tipo int:
int[][,,][,] numbers;
Constructores en C#
Constructores en C#
Cada vez que se crea una clase o estructura, se llama a su constructor. Una clase
o estructura puede tener varios constructores que toman argumentos diferentes.
Los constructores permiten al programador establecer valores predeterminados,
limitar la creación de instancias y escribir código flexible y fácil de leer.
En C# podemos definir un método que se ejecute inicialmente y en forma
automática. Este método se lo llama constructor.
El constructor tiene las siguientes características:
 Tiene el mismo nombre de la clase.
 Es el primer método que se ejecuta.
 Se ejecuta en forma automática.
 No puede retornar datos.
 Se ejecuta una única vez.
 Un constructor tiene por objetivo inicializar atributos.
Sintaxis de un Constructor en C#
Modificador NombredelaClase (Parámetros)
{
Instrucciones

}
Veamos un Ejemplo de un constructor en C#
using System;
namespace constructores
class EjConstructor
int a;
int b;
//declaramos el constructor
public EjConstructor(int x, int y)
a = x;
b = y;
public int Suma()
return a + b;
public int resta()
return a - b;
class Principal
//creamos objeto de la clase y le pasamos los parametros al

constructor
EjConstructor obj = new EjConstructor(10, 20);
Console.WriteLine("La suma es: "+obj.Suma());
Console.WriteLine("La resta es: "+obj.resta());
Console.ReadKey();

El ejemplo es sencillo para que pueda comprenderse creamos una clase

EjConstructor con 2 variables enteras, luego definimos el constructor con 2
parámetros observen que tiene el mismo nombre de la clase eso tiene que ser así
obligatoriamente, también tenemos un método Suma y un método resta que lo
único que hace es realizar una suma y la resta sucesivamente.Luego en la clase
Principal al momento de crear el objeto de la clase le pasamos los parámetros de
una sola vez al constructor, y después solo imprimimos el resultado de la suma y
la resta del método Suma y resta.
Etiquetas: C#, c# constructores, clases en c#, clases y constructores en c#, constructor de una
clase en c#, constructores en c#, operaciones con vectores en c#, ordenar en c#
Búsqueda Binaria en C#
El algoritmo de búsqueda binaria es un excelente método para buscar datos
dentro de una estructura(generalmente un arreglo unidimensional). Se le da el
nombre de búsqueda binaria por que el algoritmo divide en dos el arreglo,
aludiendo al concepto de bit, el cual puede tener dos estados.
La única condición para usar este algoritmo es que los datos dentro del arreglo
estén ordenados de menor a mayor.
La solución mas fácil para realizar una búsqueda es por fuerza bruta, pero este
método puede resultar bastante ineficiente cuando se tiene una gran cantidad
de datos, ya que habría que buscar posición por posición hasta encontrar el dato
que queremos.

El código por fuerza bruta es bastante sencillo:
for(int i=0; i<Arreglo.length; i++)

if(Arreglo[i] == elemento)
System.out.println("\nElemento encontrado en la posicion: " + i);
Solo se recorre todo el arreglo y verificamos si la posición i es igual al dato que

queremos buscar, el código anterior se puede mejorar simplemente agregándole
una bandera, pero aun así no es lo suficientemente bueno.
El algoritmo de búsqueda binaria es el siguiente:
1. Se declaran los índices superior e inferior. El inferior en 0 y el
superior con el tamaño del arreglo menos 1.
2. Se calcula el centro del arreglo con la siguiente formula: centro =
(superior + inferior) / 2
3. Verificamos si el arreglo en la posición centro es igual al dato que
buscamos. Si es igual significa que encontramos el dato y retornamos
centro.
4. Si son diferentes verificamos si el arreglo en la posición centro es
mayor al dato que queremos buscar. Si es mayor actualizamos superior:
superior = centro - 1, si no actualizamos inferior: inferior = centro + 1.
5. Volvemos al paso 2.
Si cuando ya no se cumpla la condición del ciclo y no se encontró el dato
retornamos -1
indicando que el dato no se encuentra en el arreglo.
using System;
using System.Linq;
using System.Text;
namespace BusquedaBinaria
class Busqueda

Console.WriteLine("Busqueda Binaria");
Console.WriteLine("Ingrese 10 Elementos");
string linea;
vector = new int[10];
public void busqueda(int num)
int l = 0, h = 9;
int m = 0;
bool found = false;
while (l <= h && found == false)
m = (l + h) / 2;
if (vector[m] == num)
found = true;
if (vector[m] > num)
h = m - 1;
else
l = m + 1;
if (found == false)
{ Console.Write("\nEl elemento {0} no esta en el arreglo", num); }
else
{ Console.Write("\nEl elemento {0} esta en la posicion: {1}", num, m

+ 1); }

Console.Write(vector[f] + " ");
Busqueda pv = new Busqueda();
pv.Cargar();
pv.Imprimir();
Console.Write("\n\nElemento a buscar: ");
int num = int.Parse(Console.ReadLine());
pv.busqueda(num);
Console.ReadKey();

Ejercicios con Clases en C#

Ejercicios con Clases en C#
Normalmente un problema resuelto con la metodología de programación
orientada a objetos no interviene una sola clase, sino que hay muchas clases que
interactúan y se comunican. Plantearemos un problema separando las
actividades en dos clases.
Ejemplo 1
Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También
el banco requiere que al final del día calcule la cantidad de dinero que hay
depositada.
La Solución tendrá el siguiente esquema: Debemos definir los atributos y los
métodos de cada clase:
Cliente
atributos
nombre
monto
métodos
constructor
Depositar
Extraer
RetornarMonto
Banco
atributos
3 Cliente (3 objetos de la clase Cliente)
métodos
constructor

Operar
DepositosTotales
Solución en C#
using System;
using System.Linq;
using System.Text;
namespace EjerciciosconClases
class Cliente
private int monto;
public Cliente(string nom)
nombre = nom;
monto = 0;
public void Depositar(int m)
monto = monto + m;
public void Extraer(int m)
monto = monto - m;
public int RetornarMonto()
return monto;
Console.WriteLine(nombre + " tiene depositado la suma de " + monto);

class Banco
private Cliente cliente1, cliente2, cliente3;
public Banco()
cliente1 = new Cliente("Yhonas");
cliente2 = new Cliente("Ana");
cliente3 = new Cliente("Pedro");
public void Operar()
cliente1.Depositar(100);
cliente3.Extraer(150);
public void DepositosTotales()
int t = cliente1.RetornarMonto() +
cliente2.RetornarMonto() +
cliente3.RetornarMonto();
Console.WriteLine("El total de dinero en el banco es:" + t);
cliente1.Imprimir();
Banco banco1 = new Banco();
banco1.Operar();
banco1.DepositosTotales();
Console.ReadKey();

Etiquetas: arrays resueltos en c#, c# ejercicios resueltos, ejemplo de búsqueda binaria en

c#,ejercicios con clases en c#
Ejercicios Resueltos de Constructores en C#

Ejercicios Resueltos de Constructores en
C#
Ejemplo 1
Realizar un programa que ingrese los sueldos de 5 operarios en un vector. Realizar
la creación y carga del vector en el constructor.
using System;
using System.Linq;
using System.Text;
namespace PruebaConstructor
class Operarios
private int[] sueldos;
public Operarios()
sueldos = new int[5];

for (int f = 0; f < sueldos.Length; f++)
Console.Write("Ingrese el sueldo "+(f+1)+": ");
sueldos[f] = int.Parse(linea);
Console.WriteLine("Los Sueldos Ingresados.");
for (int f = 0; f < sueldos.Length; f++)
Console.WriteLine(sueldos[f]);
Console.ReadKey();
Operarios op = new Operarios();
op.Imprimir();

Explicación:
Como la clase se llama Operarios el constructor tiene el mismo nombre, no
disponemos la palabra clave void ya que el constructor no puede retornar datos.
La ventaja de plantear un constructor en lugar de definir un método con cualquier
nombre es que se llamará en forma automática cuando se crea un objeto de esta
clase:
Operarios op = new Operarios();
Cuando se crea el objeto op se llama al método constructor.

Finalmente llamamos al método imprimir:
op.Imprimir();
Ejemplo 2
Plantear una clase llamada Alumno y definir como atributos su nombre y su edad.
En el constructor realizar el ingreso de datos. Definir otros dos métodos para
imprimir los datos ingresados y un mensaje si es mayor o no de edad (edad >=18)
using System;
using System.Linq;
using System.Text;
namespace PruebaConstructor
class Alumno
private int edad;
public Alumno()
Console.Write("Ingrese nombre:");
nombre = Console.ReadLine();
Console.Write("Ingrese edad:");
edad = int.Parse(linea);

Console.WriteLine("Nombre:" + nombre);
Console.WriteLine("Edad:" + edad);
public void EsMayorEdad()
if (edad >= 18)
Console.Write(nombre + " es mayor de edad.");
else
Console.Write(nombre + " no es mayor de edad.");
Alumno alumno1 = new Alumno();
alumno1.Imprimir();
alumno1.EsMayorEdad();
Console.ReadKey();
Explicación:

En la main el constructor se llama en forma automática cuando creamos un

objeto de la clase Alumno:
{
Alumno alumno1 = new Alumno();
Los otros dos métodos deben llamarse por su nombre y en el orden que
necesitemos:
alumno1.Imprimir();
alumno1.EsMayorEdad();

Ejercicios 03 PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ejercicios 03 PDF

Transféré par

Droits d'auteur :

Formats disponibles

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

ING. VLADIMIR FLOREZ TINTA 1

Ejercicios Resueltos de Estructura Condicional Compuesta ...............................................29

ING. VLADIMIR FLOREZ TINTA 2

ING. VLADIMIR FLOREZ TINTA 3

Ejercicios de Arreglos Multi-dimensionales en C# ..................................................................99

ING. VLADIMIR FLOREZ TINTA 4

Ordenamiento por Burbuja en C# ...............................................................................135

ING. VLADIMIR FLOREZ TINTA 5

ING. VLADIMIR FLOREZ TINTA 6

Introducción a Visual Studio 2013

ING. VLADIMIR FLOREZ TINTA 7

Estos son los elementos esenciales que intervienen en el desarrollo de un

ING. VLADIMIR FLOREZ TINTA 8

Escritura de la lógica del programa empleando un lenguaje de programación

ING. VLADIMIR FLOREZ TINTA 9

Publicado por Yhonatan Robles Vega 2 comentarios:

ING. VLADIMIR FLOREZ TINTA 10

En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz

Declaración de una Matriz en C#

La declaración de matrices (como se muestra arriba) no crea realmente las

string[,] names = new string[5,4];

byte[][] scores = new byte[5][];

ING. VLADIMIR FLOREZ TINTA 11

scores[x] = new byte[4];

int[,,] buttons = new int[4,5,3];

Incluso, se pueden combinar matrices rectangulares y escalonadas. Por ejemplo, el

Ejercicios Resueltos de Matrices en C#

ING. VLADIMIR FLOREZ TINTA 12

private int[,] mat;

public void Ingresar()

mat = new int[3, 4];

for (int f = 0; f < 3; f++)

for (int c = 0; c < 4; c++)

Console.Write("Ingrese posicion ["+(f+1)+","+(c+1)+"]: ");

public void Imprimir()

for (int f = 0; f < 3; f++)

for (int c = 0; c < 4; c++)

Console.Write(mat[f, c] + " ");

ING. VLADIMIR FLOREZ TINTA 13

static void Main(string[] args)

Matriz ma = new Matriz();

Al ejecutar el código muestra el siguiente resultado:

ING. VLADIMIR FLOREZ TINTA 14

El siguiente ejercicio muestra la solución del ejercicio "Hola Mundo!"

Un bloque de texto también se puede convertir en comentario si se incluye entre

ING. VLADIMIR FLOREZ TINTA 15

 Puede devolver void.

static void Main()

 También puede devolver un entero.

static int Main()

 Puede utilizar argumentos con cualquiera de los tipos devueltos.

static void Main(string[] args)

Publicado por Yhonatan Robles Vega No hay comentarios:

ING. VLADIMIR FLOREZ TINTA 16

Cuando esté listo para empezar a programar, el primer paso es preparar un

Codificación del problema con el lenguaje C#.

No debemos perder de vista que el fin último es realizar un programa de

Lenguaje de computación: Conjunto de instrucciones que son interpretadas por

Consideraciones a tener en cuenta en cada proyecto.

Pasos a Seguir para crear un proyecto en C#

1. Abrimos Visual Studio 2010 Ultimate

ING. VLADIMIR FLOREZ TINTA 17