Creando bot monitorización en c# - Capítulo 2

2. Creando bot monitorización en c# 

•  En este capítulo del curso de programación en c# con visual studio 2017 continuamos con la construcción de nuestro bot para monitorizar los cambios que se produzcan en un página determinada. Básicamente queremos saber cuando cambia un texto en una zona determinada de una página. Cuando el bot detecta un cambio desencadenara la acción que elijamos.

• Como sólo queremos detectar el cambio que se produce en una sección determinada de la página, vamos a navegar en el documento cuando lo tengamos cargado en memoria, antes de guardar en disco, para seleccionar y guardar únicamente la parte de la página que queremos monitorizar.

• Para ello utilizamos la libreria HTML Agility pack que nos facilita el trabajo.Os dejo un enlace a stackoverflow donde se explica como utilizar esta libreria: https://stackoverflow.com/questions/846994/how-to-use-html-agility-pack

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código que hemos visto en el vídeo:

//Parte que guardo pagina en disco solo lo que me interesa de la página

  try

            {

                //Video  utilizar y guardar en disco

                WebClient cliente = new WebClient();

                String pagina = String.Empty;

                pagina = cliente.DownloadString("https://www.taiestado.com/");

                    

                StreamWriter sw = new StreamWriter("D:\\Temporal.html",false);

                sw.Write(pagina);

                sw.Close();

                sw.Dispose();

                //Video 2 guardar en disco solo la parte del fichero que me interesa

                var doc = new HtmlAgilityPack.HtmlDocument();

                HtmlAgilityPack.HtmlNode.ElementsFlags["br"] = HtmlAgilityPack.HtmlElementFlag.Empty;

                doc.OptionWriteEmptyNodes = true;

                var webRequest = HttpWebRequest.Create("https://www.taiestado.com/");

                Stream stream = webRequest.GetResponse().GetResponseStream();

                doc.Load(stream);

                stream.Close();

                string testDivSelector = "//div[@id='subcomentarios']";

                var divString = doc.DocumentNode.SelectSingleNode(testDivSelector).InnerHtml.ToString();

                Console.ReadLine();

            }

            catch (Exception ex)

            {

                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine(ex.ToString());

                Console.ReadLine();

            }

        }

Creando bot monitorización en c# - Capítulo 1

1. Creando bot monitorización en c# 

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos ha empezar a construir un bot para monitorizar los cambios que se produzcan en un página determinada. Básicamente queremos saber cuando cambia un texto en una zona determinada de una página. Cuando el bot detecte un cambio desencadenara la acción que elijamos.

• Un bot  es un programa informático que efectúa automáticamente tareas repetitivas a través de Internet.Un ejemplo de bots son los rastreadores web de los motores de búsqueda de Internet, que recorren los sitios web de forma automática y recopilan información de los mismos de manera mucho más rápida y efectiva de lo que lo haría una persona.

• Os dejo un enlace  a  información más detallada sobre los diferentes tipos de bots:https://computerhoy.com/noticias/software/que-es-bot-44366

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código visto en el video, en el que guardo la página a chequear en disco:

static void Main(string[] args)

{

try

{

WebClient cliente = new WebClient();

String pagina = String.Empty;

pagina = cliente.DownloadString("https://www.taiestado.com/");

StreamWriter sw = new StreamWriter("D:\\Temporal.html", false);

sw.Write(pagina);

sw.Close();

sw.Dispose();

Console.WriteLine(pagina);

Console.ReadLine();

}

catch (Exception ex)

{

Console.ForegroundColor = ConsoleColor.Red;

Console.WriteLine(ex.ToString());

Console.ReadLine();

}

}

Algoritmos de ordenación en c# - Algoritmo Shell Sort

6. Algoritmo de ordenación Shell Sort 

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de de ordenación Shell Sort.

• El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta que  el ordenamiento por inserción es eficiente si la entrada está "casi ordenada". El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez. El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones

• Os dejo un enlace  a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Ordenamiento_Shell

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código del algoritmo visto en el vídeo:

      public static void ShellShort()

        {

            int[] array = { 15,50, 17, 72, 12, 23, 54, 76, 75, 43, 8654, 87, 654, 9 };

            mostrar(array);

            Console.WriteLine("");

            ShellShort(array);

            Console.ReadLine();

            mostrar(array);

            Console.ReadLine();

        }

        public static void ShellShort(int[] array)

        {

            int mitad = 0;

            bool ejecutar = false;

            int aux = 0;

            int x = 0;

            mitad = array.Length / 2;

            while (mitad > 0)

            {

                ejecutar = true;

                while (ejecutar)

                {

                    ejecutar = false;

                    x = 1;

                    while (x <= (array.Length - mitad))

                    {

                        if (array[x - 1] > array[(x - 1) + mitad])

                        {

                            aux = array[(x - 1) + mitad];

                            array[(x - 1) + mitad] = array[x - 1];

                            array[(x - 1)] = aux;

                            ejecutar = true;

                        }

                        x++;

                    }

                }

                mitad = mitad / 2;

            }

        }

• También os dejo el  código del proyecto con todos los algoritmos de ordenación vistos hasta ahora para descargar

Algoritmos de ordenación en c# - Algoritmo de ordenamiento por insercion

5. Algoritmo de ordenamiento por inserción

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de de ordenamiento por insercion.

•  La idea de este algoritmo de ordenación consiste en ir insertando un elemento del array en la parte ordenado del mismo, asumiendo que el primer elemento es la parte ordenada, el algoritmo ira comparando un elemento de la parte desordenada del array con los elementos de la parte ordenada, insertando el elemento en la posición correcta dentro de la parte ordenada, y así sucesivamente hasta obtener el array ordenado.

• Os dejo un enlace  a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Ordenamiento_por_inserci%C3%B3n

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código del ejemplo visto en el vídeo:

  public static void OrdenaciónDirecta()

        {

            int[] array = { 50, 17, 72, 12, 23, 54, 76,75,43 ,8654,87,654,9};

            mostrar(array);

            Console.WriteLine("");

            OrdenaciónDirecta(array);

            Console.ReadLine();

            mostrar(array);

            Console.ReadLine();

        }

        public static void OrdenaciónDirecta(int[] array)

        {

            int aux;

            int j;

            for (int i = 0; i < array.Length; i++)

            {

                aux = array[i];

                j = i - 1;

                while (j >= 0 && array[j] > aux)

                {

                    array[j + 1] = array[j];

                    j--;

                }

                array[j + 1] = aux;

            }

        }

:

Algoritmos de ordenación en c# - Algoritmo HeapShort

4. Algoritmo HeapSort

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de ordenación HeapSort.

•  Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un montículo y posteriormente  extraer el nodo que queda como nodo raíz del montículo en sucesivas iteraciones obteniendo el conjunto ordenado.

• Os dejo un enlace al pseudocódigo y a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Heapsort

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el código visto en el vídeo:

   public static void  HeapSort()

        {

            

                int[] array = { 50, 17, 72, 12, 23, 54, 76 };

                mostrar(array);

                Console.WriteLine("");

                HeapSort(array);

                Console.ReadLine();

                mostrar(array);

                Console.ReadLine();

            

        }

        static private void HeapSort(int[] array)

        {

           

            int tamanioArray = array.Length;

            for (int p = (tamanioArray - 1) / 2; p >= 0; p--)

                Maximos(array, tamanioArray, p);

            for (int i = array.Length - 1; i > 0; i--)

            {

                int temp = array[i];

                array[i] = array[0];

                array[0] = temp;

                tamanioArray--;

                Maximos(array, tamanioArray, 0);

                Console.WriteLine("");

                mostrar(array);

            }

          

        }

        private static void Maximos(int[] array, int tamanyo, int posicion)

        {

            int izquierda = (posicion + 1) * 2 - 1;

            int derecha = (posicion + 1) * 2;

            int mayor = 0;

            if (izquierda < tamanyo && array[izquierda] > array[posicion])

                mayor = izquierda;

            else

                mayor = posicion;

            if (derecha < tamanyo && array[derecha] > array[mayor])

                mayor = derecha;

            if (mayor != posicion)

            {

                int temp = array[posicion];

                array[posicion] = array[mayor];

                array[mayor] = temp;

                Maximos(array, tamanyo, mayor);

            }

        }

Algoritmos de ordenación en c# - Algoritmo Quick Sort

3. Algoritmo Quick Sort

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de ordenación Quick Sort.

• En este algoritmo se toma un elemento x de una posición del array. Se trata de ubicar a x en la posición correcta del array, 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.

• Os dejo un enlace al pseudocódigo y a  información más detallada sobre este algoritmo:https://es.wikipedia.org/wiki/Quicksort

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• Os dejo el codigo visto en el vídeo:

  public static void Quicksort()

        {

            int[] array = { 12, 17, 16, 8, 67, 1, 4, 876,21,6789, 99, 77, 6, 10, 88, 45 };

            mostrar(array);

            Console.WriteLine("");

            Quicksort(array, 0, array.Length - 1);

            Console.ReadLine();

            mostrar(array);

            Console.ReadLine();

        }

        static private void Quicksort(int[] array, int inicio, int fin)

        {

            int x, y, central;

            double pivote;

            central = (inicio + fin) / 2;

            pivote = array[central];

            x = inicio;

            y = fin;

            do

            {   

                while (array[x] < pivote) x++;

                while (array[y] > pivote) y--;

                if (x <= y)

                {

                    int aux;

                    aux = array[x];

                    array[x] = array[y];

                    array[y] = aux;

                    x++;

                    y--;

                }

            } while (x <= y);

            if (inicio < y)

            {

                Console.WriteLine();

                mostrar(array);

                Quicksort(array, inicio, y);

            }

            if (x < fin)

            {

                Console.WriteLine();

                mostrar(array);

                Quicksort(array, x, fin);

            }

          

        }

Algoritmos de ordenación en c# - Algoritmo Merge Sort

2. Algoritmo Merge Sort

•  En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar viendo algunos algoritmos de ordenación de vectores o arrays. En esta ocasión veremos el algoritmo de ordenación por mezcla o Merge Sort.

• Este algoritmo  se basa en la técnica divide y vencerás.Esta técnica consiste en dividir el problema a resolver en  problemas más pequeños del mismo tipo que a su vez se  volverán a dividir en problemas todavía mas pequeños hasta que sean  triviales.

• Os dejo un enlace al pseudocódigo y a  información más detallada sobre este algoritmo: https://es.wikipedia.org/wiki/Ordenamiento_por_mezcla

• Una vez visto esto ya podemos ver el vídeo con la explicación:

• También os dejo el código correspondiente al algoritmo explicado en el vídeo:

 public static void Mergesort()
        {
            int[] array = { 12, 17, 16, 8, 67, 1, 4, 1000, 99, 77, 6, 10 ,88, 45 };
            mostrar(array);
            Console.WriteLine("");
            MergeSort(array, 0, array.Length - 1);
            Console.ReadLine();
            mostrar(array);
            Console.ReadLine();

        }


        static private void MergeSort(int[] array, int inicio, int fin)
        {

            if (inicio == fin)
                return;

             int mitad = (inicio + fin) / 2;

            MergeSort(array, inicio, mitad);
            MergeSort(array, mitad + 1, fin);

             int[] aux = juntarArrays(array, inicio, mitad, mitad + 1, fin);

            Array.Copy(aux, 0, array, inicio, aux.Length);

            Console.WriteLine("");

            mostrar(array);

        }

    static private int[] juntarArrays(int[] x, int inicio, int fin, int inicio2, int fin2)
        {

            int aux1 = inicio;
            int aux2 = inicio2;
            int[] resultado = new int[fin - inicio + fin2 - inicio2 + 2];

            for (int i = 0; i < resultado.Length; i++)
            {

                if (aux2 != x.Length)
                {

                    if (aux1 > fin && aux2 <= fin2)
                    {
                        resultado[i] = x[aux2];
                        aux2++;
                    }

                    if (aux2 > fin2 && aux1 <= fin)
                    {
                        resultado[i] = x[aux1];
                        aux1++;
                    }

                    if (aux1 <= fin && aux2 <= fin2)
                    {
                        if (x[aux2] <= x[aux1])
                        {
                            resultado[i] = x[aux2];
                            aux2++;
                        }
                        else
                        {
                            resultado[i] = x[aux1];
                            aux1++;

                        }

                    }

                }
                else
                {
                    if (aux1 <= fin)
                    {
                       resultado[i] = x[aux1];
                        aux1++;
                    }

                }

            }
            return resultado;

        }