Obtener conjuntos de una lista en C#

El siguiente código implementa la obtención de conjuntos de datos de una lista de elementos.

namespace Ejemplos
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    /// <summary>
    /// Clase que contiene la lógica de ejecución.
    /// </summary>
    class Program
    {
        /// <summary>
        /// Método principal.
        /// </summary>
        /// <param name="args">Argumentos.</param>
        static void Main(string[] args)
        {            
            List<int> numeros = new List<int>();
                        
            int tamañoConjunto = 15;
            int numeroConjunto = 1;
                        
            for (int iterador = 1; iterador <= 100; iterador++)
            {
                numeros.Add(iterador);
            }

            Console.WriteLine("Números:");
            Console.WriteLine(string.Join(",", numeros));
            Console.WriteLine();
            Console.WriteLine(string.Concat("Tamaño del conjunto: ", tamañoConjunto));
            Console.WriteLine();

            // Se recorre la lista de números y se extraen los conjuntos.
            for (int iterador = 0; iterador < numeros.Count(); iterador+=tamañoConjunto)
            {
                Console.WriteLine(string.Format("Conjunto: {0}", numeroConjunto));
                IEnumerable<int> conjunto = numeros.Skip(iterador).Take(tamañoConjunto);
                Console.WriteLine(string.Join(",", conjunto));
                Console.WriteLine();
                numeroConjunto++;
            }

            Console.WriteLine();
            Console.WriteLine("Presiona cualquier tecla para salir...");
            Console.ReadKey();
            Environment.Exit(0);
        }
    }
}

BackTracking en C#

La siguiente aplicación de escritorio muestra como funciona el algoritmo BackTracking en la búsqueda de una salida en un laberinto proporcionado.

El laberinto puede ser modificado en la clase "Administrador" con tan solo cambiar la matriz de elementos que lo representan, para esto es necesario modificar el arreglo asignado en la propiedad "Estructura" del objeto "Laberinto", donde:

  • 'E' Representa la entrada.
  • 'S' Representa la salida.
  • '*' Representa un muro.
  • 'O' Representa las casillas libres.

Si se desea aumentar o disminuir el tamaño del laberinto, el total de filas y columnas de la nueva estructura deberá de ser actualizado en la propiedad "Filas" y "Columnas" del objeto, así como también, si se cambia la casilla de entrada y salida, se tendrán que asignar las coordenadas en la propiedad "Entrada" y "Salida" del objeto antes mencionado. 

BackTracking.rar (969,86 kb)

Método de ordenamiento burbuja en C#

El siguiente código implementa el algoritmo de ordenamiento burbuja en una aplicación de consola.

namespace OrdenamientoBurbuja
{
    #region [Bibliotecas de clases]
    using System;
    using System.Linq;
    #endregion

    /// <summary>
    /// Clase que encapsula la lógica del algoritmo de ordenamiento burbuja.
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Método de ejecución principal.
        /// </summary>
        /// <param name="args">Argumentos.</param>
        public static void Main(string[] args)
        {
            Console.WriteLine("Ingresa los numeros a ordenar separados por comas(,) y presiona la tecla Enter.");
            int[] vector = Console.ReadLine().Replace(" ", "").Split(',').Select(x => Convert.ToInt32(x)).ToArray();
            Console.WriteLine();
            Console.WriteLine("Vector ordenado:");
            Console.WriteLine(string.Join(",", Ordenar(vector)));
            Console.WriteLine();
            Console.WriteLine("Presiona una tecla para salir.");
            Console.ReadKey();
        }

        /// <summary>
        /// Método que implementa el algoritmo de ordenamiento burbuja a un vector´.
        /// </summary>
        /// <param name="vector">Vector que contiene los elementos a ordenar.</param>
        /// <returns>Vector ordenado.</returns>
        private static int[] Ordenar(int[] vector)
        {
            int auxiliar;

            for (int i = 0; i < vector.Length; i++)
            {
                for (int j = 0; j < vector.Length - i - 1; j++)
                {
                    if (vector[j + 1] < vector[j])
                    {
                        auxiliar = vector[j + 1];
                        vector[j + 1] = vector[j];
                        vector[j] = auxiliar;
                    }
                }
            }

            return vector;
        }
    }
}