Pop

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.
  • 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();
}

}
en No hay comentarios:

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
  • 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
en No hay comentarios:

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.
  • 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;
            }
        }
:
en No hay comentarios:

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.
  • 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);
            }
        }
en No hay comentarios:

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.
  • 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);
            }

          
        }
en No hay comentarios:

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.
  • 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;

        }
en 1 comentario:

Algoritmos de ordenación en c# - Algoritmo de la burbuja

1. Algoritmo de la burbuja


  •  En este capítulo del curso de programación en c# con visual studio 2017 vamos a empezar a ver algunos algoritmos de ordenación de vectores o arrays. Vamos a empezar con el algoritmo de la burbuja. 


  • Este algoritmo funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado.Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas".



     

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

        static void Main(string[] args)
        {
               int[] array = { 12, 17, 16, 8, 67, 1 };

                 mostrar(array);
            Console.ReadLine();
                int x;
                for (int i = 1; i<array.Length; i++)
                    for (int j = array.Length - 1; j >= i; j--)
                    {
                        if (array[j - 1] > array[j])
                        {
                            x = array[j - 1];
                            array[j - 1] = array[j];
                            array[j] = x;
                        }

                     }
            mostrar(array);
            Console.ReadLine();
        }

         public static void  mostrar(int[] array)
        {
            foreach (int i in array)
                Console.Write("  " + i.ToString());

         }
en No hay comentarios:

Curso de querys SQL -20- Aprende a crear usuarios en SQL


20- Aprende a crear usuarios en SQL

  • Hola a todos , en esta ocasión vamos continuar  con nuestro curso sobre SQL SERVER. En este capítulo del curso vamos a ver como crear usuarios en SQL. En ocasiones es necesario restringir el acceso de los usuarios sólo a una de las bases de datos que tengamos en la instancia o quizás solo a determinados objetos de una base de datos.
  • Os dejo el vídeo con la explicación, en el que vemos como crear un usuario que sólo tenga acceso a una de las bases de datos de las tres que tenemos almacenadas en el sistema.

en No hay comentarios:

Curso de querys SQL -19 -Descubre como crear vistas en SQL


19 .Descubre como crear vistas en SQL

  • Hola a todos , en esta ocasión vamos continuar  con nuestro curso sobre SQL SERVER. En este capítulo del curso vamos a ver como crear vistas en SQL. Una vista no es más que una tabla virtual cuyo contenido se define mediante una consulta.
  • El contenido del vídeo que pongo a continuación está basado en el siguiente esquema,que los veterenos del blog ya conoceréis:


  • Aquí tenéis el vídeo con la explicación:


  • Os dejo el código para la creación de la vista que hemos visto en el vídeo:
CREATE VIEW [dbo].[Prueba3]
AS
SELECT        dbo.PEDIDOS.IdPedido, dbo.USUARIOS.IdUsuario, dbo.USUARIOS.Nombre, dbo.USUARIOS.Email,FechaPedido
FROM            dbo.PEDIDOS INNER JOIN
                         dbo.PEDIDOS_LINEAS ON dbo.PEDIDOS.IdPedido = dbo.PEDIDOS_LINEAS.IdPedido INNER JOIN
                       dbo.PRODUCTOS ON dbo.PEDIDOS_LINEAS.IdProducto = dbo.PRODUCTOS.IdProducto INNER JOIN
                         dbo.USUARIOS ON dbo.PEDIDOS.IdUsuario = dbo.USUARIOS.IdUsuario  
GO

en No hay comentarios:

Batallas del abuelo - Como conseguí mi primer empleo como desarrollador


Batallas del abuelo - Como conseguí mi primer empleo como desarrollador  

  • Hola a todos , en esta ocasión cambio un poco el tono y os cuento como conseguí mi primer empleo en el mundillo de la informática, una vez finalizada la carrera. 
  • En vídeo  os cuento como encontré el primer trabajo.Mientras os cuento mis aventuras y desventuras implemento  un pequeño script que os dejo más abajo.



  • Script visto en el video:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Beep();
            Console.WriteLine(" BIEN, BIEEN !!!!!!!!! Acabo la carrera");
            Console.WriteLine("Ahora empiezo a trabajar en Madrid");
            Console.ReadLine();
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(" MINI -EMPRESA ME CONTRATA");
            Console.ForegroundColor = ConsoleColor.Green;
            Console.ReadLine();
            Console.WriteLine("Toca buscar piso");
            Console.ForegroundColor = ConsoleColor.Red;
            Console.ReadLine();
            int piso = 0;
            while (piso < 10)
            {
                piso++;
                Console.WriteLine("VER PISOS..........");
                Console.ReadLine();
            }
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("BIEN TENGO PISO CERCA DEL TRABAJO !!!!!!!!!!!!!");
            Console.ReadLine();
            int tiempo=7;
            while (tiempo < 2)
            {
                tiempo++;
                Console.WriteLine("Oficina cerca del piso");
                Console.ReadLine();
            }

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Ahora eres experto en PROJECT. TIRA PAL CLIENTE A FACTURAR");
            Console.WriteLine("DESCUBRO 2 años de mi vida xdddddddddddddddddd que tenía desubicados");

            Console.ReadLine();
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Empiezo a currar en ese cliente ubicado en tres cantos");

            Console.WriteLine("Si gusta el video os sigo contando mi vida laboral");
            Console.ReadLine();
            Console.WriteLine("Como no sabía que poner de fondo me escrito este mini proyecto para que tengías algo de fondo xddddddd");
            Console.WriteLine("CONTINUARA");

            Console.ReadLine();
        }
    }
}
en No hay comentarios:

Curso de querys SQL -18 -Descubre como utilizar INNER JOIN,LEFT JOIN...


18 .Descubre como utilizar INNER JOIN,LEFT JOIN...

  • Hola a todos , en esta ocasión vamos continuar  con nuestro curso sobre SQL SERVER. En este capítulo del curso vamos a ver para que se utilizan las operaciones inner join, left join  y right join. Un join no es más que una operación que relaciona dos o más tablas para obtener un resultado que incluya datos (campos y registros) de ambas; las tablas participantes se combinan según los campos comunes a ambas tablas.
  • Tenéis una definición más correcta y completa sobre estas sentencias en los siguientes enlaces:
  • Los ejemplos que haremos en este capítulo están basados en este diagrama de tablas:


  • Os dejo el vídeo con ejemplos de las operaciones antes mencionadas:

* Os dejo el código de los ejemplos también:
  • INNER JOIN


SELECT * FROM USUARIOS  INNER JOIN PEDIDOS ON USUARIOS.IdUsuario = PEDIDOS.IdUsuario
  • LEFT JOIN
SELECT * FROM USUARIOS LEFT JOIN PEDIDOS ON USUARIOS.IdUsuario = PEDIDOS.IdUsuario
  • RIGHT JOIN
SELECT * FROM PEDIDOS  RIGHT JOIN  USUARIOS ON  PEDIDOS.IdUsuario=  USUARIOS.IdUsuario
  • FULL JOIN
SELECT * FROM PEDIDOS  FULL JOIN  USUARIOS ON  PEDIDOS.IdUsuario=  USUARIOS.IdUsuario
en No hay comentarios:
Suscribirse a: Entradas (Atom)

Curso .NET Core en C# - 34.Creamos nuestro propio log

34.Creamos nuestro propio log Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de  ASP.NET...