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

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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 ING. VLADIMIR FLOREZ TINTA

2

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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 ING. VLADIMIR FLOREZ TINTA

3

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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 ING. VLADIMIR FLOREZ TINTA

4

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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 ING. VLADIMIR FLOREZ TINTA

5

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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

ING. VLADIMIR FLOREZ TINTA

6

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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:

ING. VLADIMIR FLOREZ TINTA

7

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.

ING. VLADIMIR FLOREZ TINTA

8

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.

ING. VLADIMIR FLOREZ TINTA

9

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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)

ING. VLADIMIR FLOREZ TINTA

10

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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: Matrices unidimensionales: int[] numbers = new int[5]; string[,] names = new string[5,4]; byte[][] scores = new byte[5][]; for (int x = 0; x < scores.Length; x++) {

ING. VLADIMIR FLOREZ TINTA

11

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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;

ING. VLADIMIR FLOREZ TINTA

12

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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] + " "); }

ING. VLADIMIR FLOREZ TINTA

13

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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! ING. VLADIMIR FLOREZ TINTA

14

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

El siguiente ejercicio muestra la solución del ejercicio "Hola Mundo!" using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Primer_Proyecto { class Program { static void Main(string[] args) { 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 ING. VLADIMIR FLOREZ TINTA

15

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.

static void Main(string[] args) { //... }

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# ING. VLADIMIR FLOREZ TINTA

16

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

ING. VLADIMIR FLOREZ TINTA

17

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.

ING. VLADIMIR FLOREZ TINTA

18

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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# 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.Collections.Generic; using System.Linq; using System.Text; namespace PerimetroCuadrado { class Program { static void Main(string[] args) { int lado, perimetro; string linea; Console.Write("Ingrese el lado del cuadrado:"); linea = Console.ReadLine(); lado = int.Parse(linea); perimetro = lado * 4; Console.Write("El perímetro del cuadrado es:"); Console.Write(perimetro); Console.ReadKey();

ING. VLADIMIR FLOREZ TINTA

19

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } }

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.Collections.Generic; using System.Linq; using System.Text; namespace SumaProductos4Numeros { class Program { static void Main(string[] args) { int num1, num2, num3, num4, suma, producto; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); Console.Write("Ingrese tercer valor:"); linea = Console.ReadLine(); num3 = int.Parse(linea); Console.Write("Ingrese cuarto valor:"); linea = Console.ReadLine(); num4 = int.Parse(linea); 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();

ING. VLADIMIR FLOREZ TINTA

20

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 3 Realizar un programa que lea cuatro valores numéricos e informar su suma y promedio. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SumaPromedio { class Program { static void Main(string[] args) { int num1, num2, num3, num4, suma, promedio; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); Console.Write("Ingrese tercer valor:"); linea = Console.ReadLine(); num3 = int.Parse(linea); Console.Write("Ingrese cuarto valor:"); linea = Console.ReadLine(); num4 = int.Parse(linea); suma = num1 + num2 + num3 + num4; promedio = suma / 4; Console.Write("La suma de los cuatro valores es:"); Console.WriteLine(suma); Console.Write("El promedio es:"); Console.Write(promedio); Console.ReadKey(); } }

ING. VLADIMIR FLOREZ TINTA

21

HERRAMIENTAS DE DESARROLLO DE SOFTWARE }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text; namespace CostoCompra { class Program { static void Main(string[] args) { int cantidad; float precio, importe; string linea; Console.Write("Ingrese la cantidad de artículos a llevar:"); linea = Console.ReadLine(); cantidad = int.Parse(linea); Console.Write("Ingrese el valor unitario del producto:"); linea = Console.ReadLine(); precio = float.Parse(linea); importe = precio * cantidad; Console.Write("El importe total a pagar es:"); Console.Write(importe); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

22

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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.

Ejercicios Resueltos de Estructura Secuencial en C# Ejemplo 1 Realizar la carga de dos números enteros por teclado e imprimir su suma y su producto. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SumaProductoNumeros { class Program { static void Main(string[] args)

ING. VLADIMIR FLOREZ TINTA

23

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { int num1, num2, suma, producto; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); suma = num1 + num2; producto = num1 * num2; Console.Write("La suma de los dos valores es:"); Console.WriteLine(suma); Console.Write("El producto de los dos valores es:"); Console.WriteLine(producto); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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 ING. VLADIMIR FLOREZ TINTA

24

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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:

ING. VLADIMIR FLOREZ TINTA

25

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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. Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace SumaPromedio { class Program {

ING. VLADIMIR FLOREZ TINTA

26

HERRAMIENTAS DE DESARROLLO DE SOFTWARE static void Main(string[] args) { int num1, num2, num3, num4, suma, promedio; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); Console.Write("Ingrese tercer valor:"); linea = Console.ReadLine(); num3 = int.Parse(linea); Console.Write("Ingrese cuarto valor:"); linea = Console.ReadLine(); num4 = int.Parse(linea); suma = num1 + num2 + num3 + num4; promedio = suma / 4; Console.Write("La suma de los cuatro valores es:"); Console.WriteLine(suma); Console.Write("El promedio es:"); Console.Write(promedio); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text; namespace CostoCompra { class Program { static void Main(string[] args) { int cantidad;

ING. VLADIMIR FLOREZ TINTA

27

HERRAMIENTAS DE DESARROLLO DE SOFTWARE float precio, importe; string linea; Console.Write("Ingrese la cantidad de artículos a llevar:"); linea = Console.ReadLine(); cantidad = int.Parse(linea); Console.Write("Ingrese el valor unitario del producto:"); linea = Console.ReadLine(); precio = float.Parse(linea); importe = precio * cantidad; Console.Write("El importe total a pagar es:"); Console.Write(importe); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.

ING. VLADIMIR FLOREZ TINTA

28

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalCompuesta1 { class Program { static void Main(string[] args) { int num1, num2; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); if (num1 > num2) { Console.Write(num1); } else { Console.Write(num2); } Console.ReadKey(); }

ING. VLADIMIR FLOREZ TINTA

29

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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 Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el mayor de ellos. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalCompuesta1 { class Program { static void Main(string[] args) { int num1, num2; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea);

ING. VLADIMIR FLOREZ TINTA

30

HERRAMIENTAS DE DESARROLLO DE SOFTWARE if (num1 > num2) { Console.Write(num1); } else { Console.Write(num2); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2 Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el mayor de ellos. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalCompuesta1 { class Program { static void Main(string[] args) {

ING. VLADIMIR FLOREZ TINTA

31

HERRAMIENTAS DE DESARROLLO DE SOFTWARE int num1, num2; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); if (num1 > num2) { Console.Write(num1); } else { Console.Write(num2); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq;

ING. VLADIMIR FLOREZ TINTA

32

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Text; namespace EstructuraCondicionalSimple2 { class Program { static void Main(string[] args) { int nota1, nota2, nota3; string linea; Console.Write("Ingrese primer nota:"); linea = Console.ReadLine(); nota1 = int.Parse(linea); Console.Write("Ingrese segunda nota:"); linea = Console.ReadLine(); nota2 = int.Parse(linea); Console.Write("Ingrese tercer nota:"); linea = Console.ReadLine(); nota3 = int.Parse(linea); int promedio; promedio = (nota1 + nota2 + nota3) / 3; if (promedio >= 7) { Console.Write("Promocionado"); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

33

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalCompuesta2 { class Program { static void Main(string[] args) { int num1, num2; string linea; Console.Write("Ingrese primer valor:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segundo valor:"); linea = Console.ReadLine(); num2 = int.Parse(linea); if (num1 > num2) { int suma, diferencia;

ING. VLADIMIR FLOREZ TINTA

34

HERRAMIENTAS DE DESARROLLO DE SOFTWARE suma = num1 + num2; diferencia = num1 - num2; Console.Write("La suma de los dos valores es:"); Console.WriteLine(suma); Console.Write("La diferencia de los dos valores es:"); Console.WriteLine(diferencia); } else { int producto, division; producto = num1 * num2; 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(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2

ING. VLADIMIR FLOREZ TINTA

35

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalCompuesta3 { class Program { static void Main(string[] args) { int num; string linea; Console.Write("Ingrese un valor entero de 1 o 2 dígitos:"); linea = Console.ReadLine(); num = int.Parse(linea); if (num < 10) { Console.Write("Tiene un dígito"); } else { Console.Write("Tiene dos dígitos"); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

36

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalAnidada1 { class Program { static void Main(string[] args) { int nota1, nota2, nota3; string linea; Console.Write("Ingrese la primera nota:"); linea = Console.ReadLine(); nota1 = int.Parse(linea); Console.Write("Ingrese la segunda nota:"); linea = Console.ReadLine(); nota2 = int.Parse(linea); Console.Write("Ingrese la tercera nota:"); linea = Console.ReadLine();

ING. VLADIMIR FLOREZ TINTA

37

HERRAMIENTAS DE DESARROLLO DE SOFTWARE nota3 = int.Parse(linea); 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(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2

ING. VLADIMIR FLOREZ TINTA

38

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalAnidada2 { class Program { static void Main(string[] args) { int num1, num2, num3; string linea; Console.Write("Ingrese primer numero:"); linea = Console.ReadLine(); num1 = int.Parse(linea); Console.Write("Ingrese segunda numero:"); linea = Console.ReadLine(); num2 = int.Parse(linea); Console.Write("Ingrese tercer numero:"); linea = Console.ReadLine(); num3 = int.Parse(linea); if (num1 > num2) { if (num1 > num3) { Console.Write("El mayor es: "+num1); } else { Console.Write("El mayor es: " + num3);

ING. VLADIMIR FLOREZ TINTA

39

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } else { if (num2 > num3) { Console.Write("El mayor es: " + num2); } else { Console.Write("El mayor es: " + num3); } } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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.

ING. VLADIMIR FLOREZ TINTA

40

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalAnidada1 { class Program { static void Main(string[] args) { int nota1, nota2, nota3; string linea;

ING. VLADIMIR FLOREZ TINTA

41

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Console.Write("Ingrese la primera nota:"); linea = Console.ReadLine(); nota1 = int.Parse(linea); Console.Write("Ingrese la segunda nota:"); linea = Console.ReadLine(); nota2 = int.Parse(linea); Console.Write("Ingrese la tercera nota:"); linea = Console.ReadLine(); nota3 = int.Parse(linea); 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(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

42

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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# ING. VLADIMIR FLOREZ TINTA

43

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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. Publicado por Yhonatan Robles Vega No hay comentarios: 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.

ING. VLADIMIR FLOREZ TINTA

44

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalAnidada4 { class Program { static void Main(string[] args) { int num; string linea; Console.Write("Ingrese un numero positivo: "); linea = Console.ReadLine(); num = int.Parse(linea); 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");

ING. VLADIMIR FLOREZ TINTA

45

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraCondicionalAnidada3 { class Program { static void Main(string[] args) { int num; string linea;

ING. VLADIMIR FLOREZ TINTA

46

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Console.Write("Ingrese un numero:"); linea = Console.ReadLine(); num = int.Parse(linea); 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(); } } }

Al ejecutar el código muestra el siguiente resultado

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;

ING. VLADIMIR FLOREZ TINTA

47

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int x; x = 1; while (x <= 50) { Console.Write(x); Console.Write(" , "); x = x + 1; } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2

ING. VLADIMIR FLOREZ TINTA

48

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Realizar un programa que dado un numero n entero, imprima consecutivamente asta n

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int n, x; string linea; Console.Write("Ingrese el valor de n:"); linea = Console.ReadLine(); n = int.Parse(linea); x = 1; while (x <= n) { Console.Write(x); Console.Write(" , "); x = x + 1; } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

49

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega No hay comentarios: 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. ING. VLADIMIR FLOREZ TINTA

50

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int mult; mult = 3; while (mult <= 200) { Console.Write(mult); Console.Write(", ");

ING. VLADIMIR FLOREZ TINTA

51

HERRAMIENTAS DE DESARROLLO DE SOFTWARE mult = mult + 3; } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2

Realizar un programa que nos imprima la factorial de un numero dado desde el teclado

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int fac=1,x,n;

ING. VLADIMIR FLOREZ TINTA

52

HERRAMIENTAS DE DESARROLLO DE SOFTWARE string linea; x = 1; Console.Write("Ingrese un numero entero: "); linea = Console.ReadLine(); n = int.Parse(linea); while (x <= n) { fac = fac * x; x = x + 1; } Console.Write("La factorial es: "+fac); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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;

ING. VLADIMIR FLOREZ TINTA

53

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int x, suma, valor, promedio; string linea; x = 1; suma = 0; while (x <= 8) { Console.Write("Ingrese valor "+x+":"); linea = Console.ReadLine(); valor = int.Parse(linea); suma = suma + valor; x = x + 1; } promedio = suma / 8; Console.Write("La suma

es:");

Console.WriteLine(suma); Console.Write("El promedio es:"); Console.Write(promedio); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

54

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int n, x, valor, pares, impares; string linea; x = 1; pares = 0; impares = 0; Console.Write("Cuantos el valor de n:"); linea = Console.ReadLine(); n = int.Parse(linea);

ING. VLADIMIR FLOREZ TINTA

55

HERRAMIENTAS DE DESARROLLO DE SOFTWARE while (x <= n) { Console.Write("Ingrese el valor "+x+": "); linea = Console.ReadLine(); 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(); } } }

Al ejecutar el código muestra el siguiente resultado

Estructura repetitiva For en C# Estructura repetitiva For en C# ING. VLADIMIR FLOREZ TINTA

56

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.

ING. VLADIMIR FLOREZ TINTA

57

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ahora para entender mas sobre las estructuras repetitivas for vamos a ver algunos ejemplos que nos ayudaran a entender mejor el tema. Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int fac=1,x,n; string linea; x = 1; Console.Write("Ingrese un numero entero: "); linea = Console.ReadLine(); n = int.Parse(linea); while (x <= n) { fac = fac * x; x = x + 1; } Console.Write("La factorial es: "+fac); Console.ReadKey(); }

ING. VLADIMIR FLOREZ TINTA

58

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int n; string linea; Console.Write("Ingrese multiplicador: "); linea = Console.ReadLine(); n = int.Parse(linea); for(int i=1; i<=15; i++ ) { Console.Write(i+" x "+n+" = "+i*n+"\n");

ING. VLADIMIR FLOREZ TINTA

59

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq;

ING. VLADIMIR FLOREZ TINTA

60

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int n,valor,positivos,negativos,pares,impares; positivos = 0; negativos = 0; pares = 0; impares = 0; string linea; Console.Write("Ingrese valor de n: "); linea = Console.ReadLine(); n = int.Parse(linea); for(int i=1; i<=n; i++ ) { Console.Write("Ingrese numero "+i+": "); linea = Console.ReadLine(); valor = int.Parse(linea); if (valor > 0) { positivos++; } else { if (valor < 0) { negativos++; } } if (valor % 2 == 0) { pares++;

ING. VLADIMIR FLOREZ TINTA

61

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } 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(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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

ING. VLADIMIR FLOREZ TINTA

62

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

ingresado por el teclado using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int fac=1,n; string linea; Console.Write("Ingrese un numero entero: "); linea = Console.ReadLine(); n = int.Parse(linea); for(int i=1; i<=n; i++ ) { fac = fac * i; } Console.Write("La factorial es: "+fac); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

63

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int n; string linea; Console.Write("Ingrese un numero entero: "); linea = Console.ReadLine(); n = int.Parse(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(); }

ING. VLADIMIR FLOREZ TINTA

64

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } }

Al ejecutar el código muestra el siguiente resultado

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. ING. VLADIMIR FLOREZ TINTA

65

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Publicado por Yhonatan Robles Vega No hay 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#

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaWhile { class Program { static void Main(string[] args) { int n; string linea; Console.Write("Ingrese multiplicador: "); linea = Console.ReadLine(); n = int.Parse(linea); for(int i=1; i<=15; i++ ) { Console.Write(i+" x "+n+" = "+i*n+"\n"); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

66

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaDoWhile { class Program { static void Main(string[] args) { int cuenta;

ING. VLADIMIR FLOREZ TINTA

67

HERRAMIENTAS DE DESARROLLO DE SOFTWARE float saldo, suma; string linea; suma = 0; do { Console.Write("Ingrese número de cuenta:"); linea = Console.ReadLine(); cuenta = int.Parse(linea); if (cuenta >= 0) { Console.Write("Ingrese saldo:"); linea = Console.ReadLine(); 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();

ING. VLADIMIR FLOREZ TINTA

68

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text; namespace EstructuraRepetitivaDoWhile { class Program { static void Main(string[] args) { int suma, cant, valor, promedio;

ING. VLADIMIR FLOREZ TINTA

69

HERRAMIENTAS DE DESARROLLO DE SOFTWARE string linea; suma = 0; cant = 0; do { Console.Write("Ingrese un nimero (0 para finalizar):"); linea = Console.ReadLine(); valor = int.Parse(linea); 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:"); Console.Write(promedio); } else { Console.Write("No se ingresaron valores "); } Console.ReadLine(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

70

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace CadenaDeCaracteres { class Program { static void Main(string[] args) { String nombre1, nombre2; int edad1, edad2; String linea; Console.Write("Ingrese el nombre 1:"); nombre1 = Console.ReadLine(); Console.Write("Ingrese edad 1:"); linea = Console.ReadLine(); edad1 = int.Parse(linea); Console.Write("Ingrese el nombre 2:"); nombre2 = Console.ReadLine(); Console.Write("Ingrese edad 2:"); linea = Console.ReadLine(); edad2 = int.Parse(linea); if (edad1 > edad2) { Console.Write("La persona de mayor edad es:"+nombre1); }

ING. VLADIMIR FLOREZ TINTA

71

HERRAMIENTAS DE DESARROLLO DE SOFTWARE else { Console.Write("La persona de mayor edad es:"+nombre2); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text; namespace CadenaDeCaracteres { class Program { static void Main(string[] args) { string apenom1, apenom2; int edad1, edad2; string linea; Console.Write("Ingrese apellido y nombre 1:");

ING. VLADIMIR FLOREZ TINTA

72

HERRAMIENTAS DE DESARROLLO DE SOFTWARE apenom1 = Console.ReadLine(); Console.Write("Ingrese edad 1:"); linea = Console.ReadLine(); edad1 = int.Parse(linea); Console.Write("Ingrese apellido y nombre 2:"); apenom2 = Console.ReadLine(); Console.Write("Ingrese edad 2:"); linea = Console.ReadLine(); edad2 = int.Parse(linea); Console.Write("La persona de mayor edad es:"); if (edad1 > edad2) { Console.Write(apenom1); } else { Console.Write(apenom2); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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# ING. VLADIMIR FLOREZ TINTA

73

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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() ING. VLADIMIR FLOREZ TINTA

74

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace CadenaDeCaracteres { class Program { static void Main(string[] args) { string nombre1, nombre2; Console.Write("Ingrese primer nombre:"); nombre1 = Console.ReadLine(); Console.Write("Ingrese segundo nombre:"); nombre2 = Console.ReadLine(); if (nombre1 == nombre2) { Console.Write("Los nombres son iguales"); } else {

ING. VLADIMIR FLOREZ TINTA

75

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Console.Write("Los nombres son distintos"); } Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; 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:"); linea = Console.ReadLine(); lado1 = int.Parse(linea);

ING. VLADIMIR FLOREZ TINTA

76

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Console.Write("Ingrese lado 2:"); linea = Console.ReadLine(); lado2 = int.Parse(linea); Console.Write("Ingrese lado 3:"); linea = Console.ReadLine(); lado3 = 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) { Console.WriteLine(lado2); } else { Console.WriteLine(lado3); } } } //Metodo es equilatero public void EsEquilatero() { if (lado1 == lado2 && lado1 == lado3) { Console.Write("Es un triángulo equilátero"); }

ING. VLADIMIR FLOREZ TINTA

77

HERRAMIENTAS DE DESARROLLO DE SOFTWARE else { Console.Write("No es un triángulo equilátero"); } } static void Main(string[] args) { Triangulo triangulo1 = new Triangulo(); triangulo1.Inicializar(); triangulo1.LadoMayor(); triangulo1.EsEquilatero(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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()

{}

ING. VLADIMIR FLOREZ TINTA

78

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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: static void Main(string[] args) { 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaClase { class Persona { private string nombre;

ING. VLADIMIR FLOREZ TINTA

79

HERRAMIENTAS DE DESARROLLO DE SOFTWARE private int edad; //Método Inicializar() public void Inicializar() { Console.Write("Ingrese nombre:"); nombre = Console.ReadLine(); string linea; Console.Write("Ingrese edad:"); linea = Console.ReadLine(); edad = int.Parse(linea); } //Método Imprimir() public void 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 static void Main(string[] args)

ING. VLADIMIR FLOREZ TINTA

80

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { 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 } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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.

ING. VLADIMIR FLOREZ TINTA

81

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

ING. VLADIMIR FLOREZ TINTA

82

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Declaración de varios Objetos dentro de un Clase

ING. VLADIMIR FLOREZ TINTA

83

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

ING. VLADIMIR FLOREZ TINTA

84

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaClase { class Cuadrado { private int lado; //método Inicializar() public void Inicializar() { Console.Write("Ingrese valor del lado:"); string linea;

ING. VLADIMIR FLOREZ TINTA

85

HERRAMIENTAS DE DESARROLLO DE SOFTWARE linea = Console.ReadLine(); 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 static void Main(string[] args) { Cuadrado cuadrado1 = new Cuadrado(); cuadrado1.Inicializar(); cuadrado1.ImprimirPerimetro(); al método ImprimirPerimetro();

//Llamando al método Inicializar(); //Llamando

cuadrado1.ImprimirSuperficie(); //Llamando al método ImprimirSuperficie(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

86

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaClase { class Operaciones { private int valor1, valor2; // Método Inicializar() public void Inicializar() { string linea; Console.Write("Ingrese primer numero:"); linea = Console.ReadLine(); valor1 = int.Parse(linea); Console.Write("Ingrese segundo numero:"); linea = Console.ReadLine(); valor2 = int.Parse(linea); } // Método Sumar() public void Sumar()

ING. VLADIMIR FLOREZ TINTA

87

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { 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 static void Main(string[] args) { 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();

ING. VLADIMIR FLOREZ TINTA

88

HERRAMIENTAS DE DESARROLLO DE SOFTWARE operacion1.Dividir();

// Llamando al método Dividir();

Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

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.

ING. VLADIMIR FLOREZ TINTA

89

HERRAMIENTAS DE DESARROLLO DE SOFTWARE int[] valores; //valores sin inicializar valores = new int[100]; valores = new int[20];

//100 elementos //ahora contiene 20 elementos

Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace EspacioMayorMenor { class MayorMenor { public void cargarValores() { string linea; Console.Write("Ingrese primer numero:"); linea = Console.ReadLine(); int valor1 = int.Parse(linea); Console.Write("Ingrese segundo numero:"); linea = Console.ReadLine(); int valor2 = int.Parse(linea); Console.Write("Ingrese tercer numero:"); linea = Console.ReadLine(); int valor3 = int.Parse(linea); int mayor, menor; mayor = CalcularMayor(valor1, valor2, valor3);

ING. VLADIMIR FLOREZ TINTA

90

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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)

ING. VLADIMIR FLOREZ TINTA

91

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { m = v2; } else { m = v3; } } return m; } static void Main(string[] args) { MayorMenor mm = new MayorMenor(); mm.cargarValores(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2 En el ejemplo siguiente, Persona es el tipo y persona1 y persona2 son instancias, u objetos, de ese tipo.

using System;

ING. VLADIMIR FLOREZ TINTA

92

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Collections.Generic; 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; Console.WriteLine("Nombre persona2 = {0} Edad = {1}", person2.Name, person2.Age); Console.WriteLine("Nombre persona1 = {0} Edad = {1}", person1.Name, person1.Age); // Mantenga la consola abierta en modo de depuración. Console.WriteLine("Presione enter para continuar");

ING. VLADIMIR FLOREZ TINTA

93

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Console.ReadKey(); } } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; 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

ING. VLADIMIR FLOREZ TINTA

94

HERRAMIENTAS DE DESARROLLO DE SOFTWARE for (int f = 1; f< = 5; f++) { Console.Write("Ingrese sueldo del operario "+f+": "); String linea; linea = Console.ReadLine(); sueldos[f] = int.Parse(linea); //Asignamos los 5 sueldos al vector } } //Muestra los sueldos de los operarios en el vector sueldos[f] public void Imprimir() { Console.Write("Los 5 sueldos de los aperarios \n"); for (int f = 1; f< = 5; f++) { Console.Write("["+sueldos[f]+"] "); } Console.ReadKey(); } //main principal static void Main(string[] args) { PruebaVector1 pv = new PruebaVector1(); pv.Cargar(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

95

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector3 { private float[] turnoM; //Declaramos un vector para el turno mañana

ING. VLADIMIR FLOREZ TINTA

96

HERRAMIENTAS DE DESARROLLO DE SOFTWARE private float[] turnoT; //Declaramos un vector para el turno tarde public void Cargar() { 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)+": "); linea = Console.ReadLine(); 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)+": "); linea = Console.ReadLine(); 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);

ING. VLADIMIR FLOREZ TINTA

97

HERRAMIENTAS DE DESARROLLO DE SOFTWARE Console.ReadKey(); } static void Main(string[] args) { PruebaVector3 pv = new PruebaVector3(); pv.Cargar(); pv.CalcularGastos(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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

ING. VLADIMIR FLOREZ TINTA

98

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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 Multidimensionales 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector2 { class PruebaVector2 { private float[] alturas; private float promedio; public void Cargar() { 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); }

ING. VLADIMIR FLOREZ TINTA

99

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } public void CalcularPromedio() { float suma; suma = 0; for (int f = 0; f< 5; f++) { suma = suma + alturas[f]; } promedio = suma / 5; 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();

ING. VLADIMIR FLOREZ TINTA

100

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } static void Main(string[] args) { PruebaVector2 pv2 = new PruebaVector2(); pv2.Cargar(); pv2.CalcularPromedio(); pv2.MayoresMenores(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector6 { class PruebaVector6

ING. VLADIMIR FLOREZ TINTA

101

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { 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 public void Cargar() { 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; linea = Console.ReadLine(); 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; linea = Console.ReadLine(); 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]; }

ING. VLADIMIR FLOREZ TINTA

102

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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(); } static void Main(string[] args) { PruebaVector6 pv = new PruebaVector6(); pv.Cargar(); pv.CalcularPromedios(); } } }

Al ejecutar el código muestra el siguiente resultado

Suma de vectores en C#

Suma de vectores en C# Realizar un programa que sume dos vectores y los almacene en un tercer vector ING. VLADIMIR FLOREZ TINTA

103

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] A;//Declaramos un vector A private int[] B;//Declaramos un vector B private int[] C;//Declaramos un vector C public void Cargar() { Console.Write("Ingrese la longitud de los vectores a sumar: "); string linea; linea = Console.ReadLine(); 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 ) +"]: "); linea = Console.ReadLine(); 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) + "]: "); linea = Console.ReadLine(); B[j] = int.Parse(linea); }

ING. VLADIMIR FLOREZ TINTA

104

HERRAMIENTAS DE DESARROLLO DE SOFTWARE for (int i = 0; i< A.Length; i++) { C[i]=A[i]+B[i]; } } public void Visualizar() { Console.WriteLine("La suma de los vecores es: "); for (int i = 0; i< A.Length; i++) { Console.Write("["+C[i]+"] "); } Console.ReadLine(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Visualizar(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

105

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega 1 comentario: 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private string[] nombres; //Declaramos un vector de tipo estring para los nombres

ING. VLADIMIR FLOREZ TINTA

106

HERRAMIENTAS DE DESARROLLO DE SOFTWARE private float[] sueldos; //Declaramos un vector de tipo float para los sueldos public void Cargar() { 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; linea = Console.ReadLine(); 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(); }

ING. VLADIMIR FLOREZ TINTA

107

HERRAMIENTAS DE DESARROLLO DE SOFTWARE static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.MayorSueldo(); } } }

Al ejecutar el código muestra el siguiente resultado

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.Collections.Generic; using System.Linq; using System.Text;

ING. VLADIMIR FLOREZ TINTA

108

HERRAMIENTAS DE DESARROLLO DE SOFTWARE namespace PruebaVector { class PruebaVector { private int[] vec;//Declaramos un vector private int menor; public void Cargar() { Console.Write("Ingrese la longitud del vector:"); string linea; linea = Console.ReadLine(); int n = int.Parse(linea); vec = new int[n]; for (int f = 0; f < vec.Length; f++) { Console.Write("Ingrese componente ["+(f+1)+"]: "); linea = Console.ReadLine(); 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() {

ING. VLADIMIR FLOREZ TINTA

109

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.MenorElemento(); pv.RepiteMenor(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

110

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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: [ , ...]; 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. ING. VLADIMIR FLOREZ TINTA

111

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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: =new [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

Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] A;//Declaramos un vector A private int[] B;//Declaramos un vector B private int[] C;//Declaramos un vector C public void Cargar() { Console.Write("Ingrese la longitud de los vectores a restar: "); string linea; linea = Console.ReadLine(); 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++)

ING. VLADIMIR FLOREZ TINTA

112

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { Console.Write("Ingrese componente [" + ( i + 1 ) +"]: "); linea = Console.ReadLine(); 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) + "]: "); linea = Console.ReadLine(); B[j] = int.Parse(linea); } for (int i = 0; i< A.Length; i++) { C[i]=A[i]-B[i]; } } public void Visualizar() { Console.WriteLine("La resta de los vecores es: "); for (int i = 0; i< A.Length; i++) { Console.Write("["+C[i]+"] "); } Console.ReadLine(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Visualizar(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo de Matrices en C#

Ejemplo de Matrices en C# Realizar un programa que permita imprimir la siguiente serie:

ING. VLADIMIR FLOREZ TINTA

113

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[,] serie; public void Cargar() { 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; } } }

ING. VLADIMIR FLOREZ TINTA

114

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } public void visualizar() { for (int i = 1; i< = 6; i++) { Console.Write("\n"); for (int j = 1; j <= 6; j++) { Console.Write(serie[i,j]+" "); } } Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.visualizar(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: Etiquetas: arreglos multidimensionales en c#, arreglos y vectores en c#, ejemplo con matrices en c#, ejercicios de matrices en C#, matrices en c#

Ejercicios Resueltos de Matrices en C# ING. VLADIMIR FLOREZ TINTA

115

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ejercicios Resueltos de 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector10 { class PruebaVector { private string[] nombres; private int[] edades; public void Cargar() { 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; linea = Console.ReadLine(); edades[f] = int.Parse(linea); } } public void MayoresEdad() { Console.WriteLine("Personas mayores de edad."); for (int f = 0; f < nombres.Length; f++)

ING. VLADIMIR FLOREZ TINTA

116

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { if (edades[f] >= 18) { Console.WriteLine(nombres[f]); } } Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.MayoresEdad(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 2 Realizar un programa que permita imprimir la siguiente serie: 1 0 1 0 1 0 1 0 1 0 1 0 ING. VLADIMIR FLOREZ TINTA

117

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[,] serie; public void Cargar() { 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; } } } } public void visualizar() {

ING. VLADIMIR FLOREZ TINTA

118

HERRAMIENTAS DE DESARROLLO DE SOFTWARE for (int i = 1; i< = 5; i++) { Console.Write("\n"); for (int j = 1; j <= 6; j++) { Console.Write(serie[i,j]+" "); } } Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.visualizar(); } } }

Al ejecutar el código muestra el siguiente resultado

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.

ING. VLADIMIR FLOREZ TINTA

119

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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#

Publicado por Yhonatan Robles Vega No hay comentarios: 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# ING. VLADIMIR FLOREZ TINTA

120

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Realizar un programa que permita la suma de dos matrices de 3x3 y el resultado almacenar en un tercer matriz using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[,] MatrizA; private int[,] MatrizB; private int[,] MatrizC; public void Cargar() { 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; linea = Console.ReadLine(); 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; linea = Console.ReadLine(); 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 public void visualizar() { Console.WriteLine("La suma de la MatrizA y MatrizB es :"); for (int i = 1; i< = 3; i++) { Console.Write("\n"); for (int j = 1; j <= 3; j++) { Console.Write(MatrizC[i,j]+" ");

ING. VLADIMIR FLOREZ TINTA

121

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.visualizar(); } } }

Al ejecutar el código muestra el siguiente resultado

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. ING. VLADIMIR FLOREZ TINTA

122

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

5. Imprimir el nombre de la provincia con la temperatura media trimestral mayor. using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Matriz { class Matriz { private string[] paises; private int[,] tempmen; private int[] temptri; public void Cargar() { 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) + ": "); string linea = Console.ReadLine(); tempmen[f, c] = int.Parse(linea); } } } public void ImprimirTempMensuales() { for (int f = 0; f< paises.Length; f++) { Console.Write("Provincia:" + paises[f] + ":"); for (int c = 0; c < tempmen.GetLength(1); c++) { Console.Write(tempmen[f, c] + " "); } Console.WriteLine(); } } public void CalcularTemperaturaTri() { temptri = new int[4]; for (int f = 0; f< tempmen.GetLength(0); f++) { int suma = 0; for (int c = 0; c < tempmen.GetLength(1); c++) { suma = suma + tempmen[f, c]; } temptri[f] = suma / 3; } } public void ImprimirTempTrimestrales() { Console.WriteLine("Temperaturas trimestrales."); for (int f = 0; f< paises.Length; f++)

ING. VLADIMIR FLOREZ TINTA

123

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { Console.WriteLine(paises[f] + " " + temptri[f]); } } public void PaisMayorTemperaturaTri() { int may = temptri[0]; string nom = paises[0]; for (int f = 0; f< paises.Length; f++) { 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); } static void Main(string[] args) { Matriz ma = new Matriz(); ma.Cargar(); ma.ImprimirTempMensuales(); ma.CalcularTemperaturaTri(); ma.ImprimirTempTrimestrales(); ma.PaisMayorTemperaturaTri(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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: ING. VLADIMIR FLOREZ TINTA

124

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

· 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.Collections.Generic; using System.Linq; using System.Text; namespace Matriz { class Matriz { private string[] empleados; private int[,] sueldos; private int[] sueldostot; public void Cargar() { 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; linea = Console.ReadLine(); 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++) {

ING. VLADIMIR FLOREZ TINTA

125

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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); } static void Main(string[] args) { Matriz ma = new Matriz(); ma.Cargar(); ma.CalcularSumaSueldos(); ma.ImprimirTotalPagado(); ma.EmpleadoMayorSueldo(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Ordenamiento por Inserción Directa en C#

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

ING. VLADIMIR FLOREZ TINTA

126

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Text; namespace PruebaVector { class PruebaVector { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de insercion directa"); Console.Write("Cuantos longitud del vector:"); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant]; for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); 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--;

ING. VLADIMIR FLOREZ TINTA

127

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } vector[j + 1] = auxili; } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.InsercionDirecta(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega 1 comentario: 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#

ING. VLADIMIR FLOREZ TINTA

128

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de insercion directa"); Console.Write("Cuantos longitud del vector:"); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant]; for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": ");

ING. VLADIMIR FLOREZ TINTA

129

HERRAMIENTAS DE DESARROLLO DE SOFTWARE linea = Console.ReadLine(); 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; } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.InsercionDirecta();

ING. VLADIMIR FLOREZ TINTA

130

HERRAMIENTAS DE DESARROLLO DE SOFTWARE pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Ordenamiento por Shell Sort en C# Método de Ordenamiento Shell Sort en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de Shell Sort"); Console.Write("Cuantos longitud del vector:"); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant];

ING. VLADIMIR FLOREZ TINTA

131

HERRAMIENTAS DE DESARROLLO DE SOFTWARE for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); vector[f] = int.Parse(linea); } } 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;

ING. VLADIMIR FLOREZ TINTA

132

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Shell(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega 1 comentario: 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#

Ordenamiento por Inserción Binaria en C# ING. VLADIMIR FLOREZ TINTA

133

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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]);

ING. VLADIMIR FLOREZ TINTA

134

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ordenamiento por Burbuja en C#

Método de Ordenamiento Burbuja en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace

Burbuja

{ class Burbuja { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de Burbuja"); Console.Write("Cuantos longitud del vector: "); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant]; for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); vector[f] = int.Parse(linea); } } public void MetodoBurbuja() { int t; for (int a = 1; a< vector.Length; a++) for (int b = vector.Length - 1; b >= a; b--)

ING. VLADIMIR FLOREZ TINTA

135

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { if (vector[b - 1] > vector[b]) { t = vector[b - 1]; vector[b - 1] = vector[b]; vector[b] = t; } } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f< vector.Length; f++) { Console.Write(vector[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { Burbuja pv = new Burbuja(); pv.Cargar(); pv.MetodoBurbuja(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

136

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega No hay comentarios: 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#

Ordenamiento por Quick Sort en C#

Método de Ordenamiento Quick Sort en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace

quicksort

{ class Class { static void Main() { int n; Console.WriteLine("Metodo de Quick Sort"); Console.Write("Cuantos longitud del vector: "); n = Int32.Parse(Console.ReadLine()); llenar b = new llenar(n); } } class llenar { int h;

ING. VLADIMIR FLOREZ TINTA

137

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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--; }

ING. VLADIMIR FLOREZ TINTA

138

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } while (i <= j); if (primero < j) { quicksort(vector, primero, j); } if (i < ultimo) { quicksort(vector, i, ultimo); } } private void mostrar() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int i = 0; i < h; i++) { Console.Write("{0} ", vector[i]); } Console.ReadLine(); } } }

Al ejecutar el código muestra el siguiente resultado

Ordenamiento por Merge Sort en C#

ING. VLADIMIR FLOREZ TINTA

139

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Método de Ordenamiento Merge Sort en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MergeSort { class Program { static void Main(string[] args) { int[] nums = new int[40]; Console.WriteLine("Metodo de Merge Sort"); Console.Write("Cuantos longitud del vector: "); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); nums = new int[cant]; for (int f = 0; f< nums.Length; f++) { Console.Write("Ingrese elemento " + (f + 1) + ": "); linea = Console.ReadLine(); 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

ING. VLADIMIR FLOREZ TINTA

140

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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++;

ING. VLADIMIR FLOREZ TINTA

141

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } 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; } } }

Al ejecutar el código muestra el siguiente resultado ING. VLADIMIR FLOREZ TINTA

142

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega No hay comentarios: 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#

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; } }

ING. VLADIMIR FLOREZ TINTA

143

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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); for (int i = 0; i < longitud; i++)

Console.WriteLine(" " + numeros[i]);

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector {

ING. VLADIMIR FLOREZ TINTA

144

HERRAMIENTAS DE DESARROLLO DE SOFTWARE class PruebaVector { private string[] nombre; public void Cargar() { 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; } } } } public void Imprimir() { Console.WriteLine("Los nombres ordenados en forma alfabéticamente"); for (int f = 0; f < nombre.Length; f++) { Console.WriteLine(nombre[f]);

ING. VLADIMIR FLOREZ TINTA

145

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Ordenar(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Ejemplo 3

Ingresar un vector de n elementos de tipo entero. Ordenar posteriormente el vector en forma ascendente

using System; using System.Collections.Generic; using System.Linq;

ING. VLADIMIR FLOREZ TINTA

146

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Text; namespace PruebaVector { class PruebaVector { private int[] vector; public void Cargar() { Console.Write("Cuantos longitud del vector:"); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant]; for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); vector[f] = int.Parse(linea); } } public void Ordenar() { 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; }

ING. VLADIMIR FLOREZ TINTA

147

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Ordenar(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega 1 comentario: Etiquetas: c sharp, ejercicios de métodos de ordenamiento en c#, métodos de ordenamiento en c#,ordenar en c#, ordenar vectores en c#

ING. VLADIMIR FLOREZ TINTA

148

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] numeros; public void Cargar() { numeros = new int[5]; for (int f = 0; f < numeros.Length; f++) { Console.Write("Ingrese numero "+(f+1)+": ");

ING. VLADIMIR FLOREZ TINTA

149

HERRAMIENTAS DE DESARROLLO DE SOFTWARE string linea = Console.ReadLine(); numeros[f] = int.Parse(linea); } } public void Ordenar() { 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; } } } } public void Imprimir() { Console.WriteLine("Ordenado Ascendentemante"); for (int f = 0; f < numeros.Length; f++) { Console.Write(numeros[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Ordenar();

ING. VLADIMIR FLOREZ TINTA

150

HERRAMIENTAS DE DESARROLLO DE SOFTWARE pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

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.

ING. VLADIMIR FLOREZ TINTA

151

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.

ING. VLADIMIR FLOREZ TINTA

152

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

Ejemplo del Código Implementado

ING. VLADIMIR FLOREZ TINTA

153

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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; }

ING. VLADIMIR FLOREZ TINTA

154

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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]);

Publicado por Yhonatan Robles Vega No hay comentarios: 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 ING. VLADIMIR FLOREZ TINTA

155

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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[4] < A[3] 08 < 15 Si hay intercambio A[3] < A[2] 08 < 15 Si hay intercambio

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.Collections.Generic;

ING. VLADIMIR FLOREZ TINTA

156

HERRAMIENTAS DE DESARROLLO DE SOFTWARE using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de insercion directa"); Console.Write("Cuantos longitud del vector:"); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant]; for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); 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];

ING. VLADIMIR FLOREZ TINTA

157

HERRAMIENTAS DE DESARROLLO DE SOFTWARE j--; } vector[j + 1] = auxili; } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+"

");

} Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.InsercionDirecta(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Método de Ordenamiento Quick Sort en C#

ING. VLADIMIR FLOREZ TINTA

158

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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[6] >= x 27 >= 15 No hay intercambio A[5] >= x 44 >= 15 No hay intercambio A[4] >= x 16 >= 15 No hay intercambio 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 ING. VLADIMIR FLOREZ TINTA

159

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

x16 (DER-IZQ) A[8]>=x No hay intercambio A[7]>=x No hay intercambio A[6]>=x No hay intercambio A[5]>=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

ING. VLADIMIR FLOREZ TINTA

160

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ejemplo del Método de Ordenamiento Quick Sort en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace quicksort { class Class { static void Main() { int n; Console.WriteLine("Metodo de Quick Sort"); Console.Write("Cuantos longitud del vector: "); 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);

ING. VLADIMIR FLOREZ TINTA

161

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int i = 0; i < h; i++) { Console.Write("{0} ", vector[i]); } Console.ReadLine(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

162

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega 1 comentario: 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.

ING. VLADIMIR FLOREZ TINTA

163

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

ING. VLADIMIR FLOREZ TINTA

164

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ejemplo del Método de Ordenamiento Shell Sort en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace PruebaVector { class PruebaVector { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de Shell Sort"); Console.Write("Cuantos longitud del vector:"); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant]; for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); vector[f] = int.Parse(linea); } } public void Shell() { int salto = 0; int sw = 0; int auxi = 0; int e = 0; salto = vector.Length / 2; while (salto > 0) { sw = 1;

ING. VLADIMIR FLOREZ TINTA

165

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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; } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+" "); } Console.ReadKey(); } static void Main(string[] args) { PruebaVector pv = new PruebaVector(); pv.Cargar(); pv.Shell(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

Método de Ordenamiento Merge Sort en C#

Método de Ordenamiento Merge Sort en C# ING. VLADIMIR FLOREZ TINTA

166

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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) ING. VLADIMIR FLOREZ TINTA

167

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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 using using using

System; System.Collections.Generic; System.Linq; System.Text;

namespace MergeSort { class Program { static void Main(string[] args) { int[] nums = new int[40]; Console.WriteLine("Metodo de Merge Sort"); Console.Write("Cuantos longitud del vector: "); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); nums = new int[cant]; for (int f = 0; f < nums.Length; f++) { Console.Write("Ingrese elemento " + (f + 1) + ": "); linea = Console.ReadLine(); 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)

ING. VLADIMIR FLOREZ TINTA

168

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { 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++; } }

ING. VLADIMIR FLOREZ TINTA

169

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } return result; } } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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#

Método de Ordenamiento Burbuja en C#

Método de Ordenamiento Burbuja 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[2] con x[3] (57 con 32) intercambio. ING. VLADIMIR FLOREZ TINTA

170

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

x[3] con x[4] (57 con 12) intercambio. x[4] con x[5] (57 con 92) no intercambio. x[5] con x[6] (92 con 86) intercambio. x[6] con x[7] (92 con 33) 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

ING. VLADIMIR FLOREZ TINTA

171

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ejemplo del Método de Ordenamiento Burbuja en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Burbuja { class Burbuja { private int[] vector; public void Cargar() { Console.WriteLine("Metodo de Burbuja"); Console.Write("Cuantos longitud del vector: "); string linea; linea = Console.ReadLine(); int cant; cant = int.Parse(linea); vector = new int[cant];

ING. VLADIMIR FLOREZ TINTA

172

HERRAMIENTAS DE DESARROLLO DE SOFTWARE for (int f = 0; f < vector.Length; f++) { Console.Write("Ingrese elemento "+(f+1)+": "); linea = Console.ReadLine(); vector[f] = int.Parse(linea); } } 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; } } } public void Imprimir() { Console.WriteLine("Vector ordenados en forma ascendente"); for (int f = 0; f < vector.Length; f++) { Console.Write(vector[f]+" "); } Console.ReadKey(); } static void Main(string[] args) { Burbuja pv = new Burbuja(); pv.Cargar(); pv.MetodoBurbuja(); pv.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

173

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Ejercicios Resueltos de Matrices en C#

Ejercicios Resueltos de Matrices en C# 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.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++)

ING. VLADIMIR FLOREZ TINTA

174

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { 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 2 ING. VLADIMIR FLOREZ TINTA

175

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace Matriz { class Matriz { private int[,] mat; public void Cargar() { 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 PrimerFila() { Console.WriteLine("\nPrimer fila de la matriz:"); for (int c = 0; c< 4; c++) {

ING. VLADIMIR FLOREZ TINTA

176

HERRAMIENTAS DE DESARROLLO DE SOFTWARE 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]+"

");

} } static void Main(string[] args) { Matriz ma = new Matriz(); ma.Cargar(); ma.PrimerFila(); ma.UltimaFila(); ma.PrimerColumna(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

177

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Publicado por Yhonatan Robles Vega No hay comentarios: 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. ING. VLADIMIR FLOREZ TINTA

178

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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: Matrices unidimensionales: 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:

Matrices unidimensionales: int[] numbers = new int[5];

Matrices multidimensionales: string[,] names = new string[5,4];

Matrices de matrices (escalonadas): byte[][] scores = new byte[5][]; ING. VLADIMIR FLOREZ TINTA

179

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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 ING. VLADIMIR FLOREZ TINTA

180

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

} 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 { static void Main(string[] args) { //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(); }

ING. VLADIMIR FLOREZ TINTA

181

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } } }

Al ejecutar el código muestra el siguiente resultado

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. Publicado por Yhonatan Robles Vega No hay comentarios: 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#

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. ING. VLADIMIR FLOREZ TINTA

182

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

El código por fuerza bruta es bastante sencillo: for(int i=0; i
Búsqueda Binaria en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace BusquedaBinaria { class Busqueda { private int[] vector; public void Cargar()

ING. VLADIMIR FLOREZ TINTA

183

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { Console.WriteLine("Busqueda Binaria"); Console.WriteLine("Ingrese 10 Elementos"); string linea; vector = new int[10]; for (int f = 0; f< vector.Length; f++) { Console.Write("Ingrese elemento " + (f + 1) + ": "); linea = Console.ReadLine(); vector[f] = int.Parse(linea); } } 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] rel="nofollow"> 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); } } public void Imprimir()

ING. VLADIMIR FLOREZ TINTA

184

HERRAMIENTAS DE DESARROLLO DE SOFTWARE { for (int f = 0; f< vector.Length; f++) { Console.Write(vector[f] + "

");

} } static void Main(string[] args) { 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();

} } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

185

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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

ING. VLADIMIR FLOREZ TINTA

186

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

Operar DepositosTotales Solución en C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace EjerciciosconClases { class Cliente { private string nombre; 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; } public void Imprimir() { Console.WriteLine(nombre + " tiene depositado la suma de " + monto); }

ING. VLADIMIR FLOREZ TINTA

187

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } 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); cliente2.Depositar(150); cliente3.Depositar(200); 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(); cliente2.Imprimir(); cliente3.Imprimir(); } static void Main(string[] args) { Banco banco1 = new Banco(); banco1.Operar(); banco1.DepositosTotales(); Console.ReadKey(); }

ING. VLADIMIR FLOREZ TINTA

188

HERRAMIENTAS DE DESARROLLO DE SOFTWARE } }

Al ejecutar el código muestra el siguiente resultado

Publicado por Yhonatan Robles Vega No hay comentarios: 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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaConstructor { class Operarios { private int[] sueldos; public Operarios() { sueldos = new int[5];

ING. VLADIMIR FLOREZ TINTA

189

HERRAMIENTAS DE DESARROLLO DE SOFTWARE for (int f = 0; f < sueldos.Length; f++) { Console.Write("Ingrese el sueldo "+(f+1)+": "); string linea = Console.ReadLine(); sueldos[f] = int.Parse(linea); } } public void Imprimir() { Console.WriteLine("Los Sueldos Ingresados."); for (int f = 0; f < sueldos.Length; f++) { Console.WriteLine(sueldos[f]); } Console.ReadKey(); } static void Main(string[] args) { Operarios op = new Operarios(); op.Imprimir(); } } }

Al ejecutar el código muestra el siguiente resultado

ING. VLADIMIR FLOREZ TINTA

190

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

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.Collections.Generic; using System.Linq; using System.Text; namespace PruebaConstructor { class Alumno { private string nombre; private int edad; public Alumno() { Console.Write("Ingrese nombre:"); nombre = Console.ReadLine(); Console.Write("Ingrese edad:"); string linea = Console.ReadLine(); edad = int.Parse(linea); }

ING. VLADIMIR FLOREZ TINTA

191

HERRAMIENTAS DE DESARROLLO DE SOFTWARE public void Imprimir() { 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."); } } static void Main(string[] args) { Alumno alumno1 = new Alumno(); alumno1.Imprimir(); alumno1.EsMayorEdad(); Console.ReadKey(); } } }

Al ejecutar el código muestra el siguiente resultado

Explicación: ING. VLADIMIR FLOREZ TINTA

192

HERRAMIENTAS DE DESARROLLO DE SOFTWARE

En la main el constructor se llama en forma automática cuando creamos un objeto de la clase Alumno: static void Main(string[] args) { Alumno alumno1 = new Alumno(); Los otros dos métodos deben llamarse por su nombre y en el orden que necesitemos: alumno1.Imprimir(); alumno1.EsMayorEdad();

ING. VLADIMIR FLOREZ TINTA

193