Programacion

Obtener último día del mes en Java

/ , / , , , , / 0 comments

Puede que nos interese saber cual es el último día de un mes concreto en Java, la mayoría de los meses es sencillo porque no varía. El problema esta con febrero que dependiendo de si el año es bisiesto o no, tendrá 28 o 29 días.

Así que para poder saber el numero de días que tiene un mes concreto se podría hacer lo siguiente:

En el ejemplo, vamos a calcular el ultimo día de febrero 2014:

Como los meses comienzan por 0, a febrero le corresponde el mes 1.

int anio=2014;
int mes=1;
Calendar calendario=Calendar.getInstance();
cal.set(2014, 1, 1);
int ultimoDiaMes=cal.getActualMaximum(Calendar.DAY_OF_MONTH);

Si consultamos la variable ultimoDiaMes, veremos que el resultado es 28.

Para dejarlo mejor, se puede crear un método para poder reutilizarlo:

public int obtenerUltimoDiaMes (int anio, int mes) {

Calendar calendario=Calendar.getInstance();
cal.set(anio, mes-1, 1);
return cal.getActualMaximum(Calendar.DAY_OF_MONTH);

}
int ultimoDiaMes=obtenerUltimoDiaMes(2014, 2);

En este caso, la variable ultimoDiaMes también valdría 28.

Detectar etiquetas HTML usando expresiones regulares en C#

/ , / 0 comments

A veces es necesario acceder de manera automatizada a sitios web, analizando el contenido de los mismos buscando datos o patrones. Una de las maneras más útiles y flexibles de desarrollar estas tareas es mediante el uso de expresiones regulares.

Una expresión regular es un texto formado por símbolos específicos, que componen un patrón. Este patrón se emplea para localizar elementos en un texto que cumplan los criterios establecidos.

<h1>(.*)</h1>

Esta expresión coincidirá para cualquier título que contenga la página. El significado es sencillo: El punto significa cualquiercaracter, incluídos los saltos de línea, y el asterisco significa ninguno o cualquier número de ellos. Los paréntesis significan que es un grupo, es decir, que queremos capturar ese contenido (no solo comprobar que está en el texto).

Esto, en el contexto de C# se define de la siguiente manera:

string pattern = "<h1>(.*)<\\/h1>";
string text = @"<html>
                    <head>
                    </head>
                    <body>
                    <h1 class=""title"">Hola mundo</h1>
                    <h1>Noticia de ultima hora</h1>
                    </body>
                    </html>";
 
MatchCollection matches = Regex.Matches(text, pattern);
foreach (Match item in matches)
{
    Console.WriteLine(item.Groups[1].Value);
}

En este código se pueden ver varios elementos, la variable patterncontiene el patrón a encontrar (con las barras verticales correctamente escapadas), la variable text el texto en el que se quiere buscar, y luego el código que realiza la búsqueda.

Como lo que se quiere es encontrar todas las apariciones y no solo una, se usa Regex.Matches en vez de Regex.Match, y luego se itera entre cada uno de los elementos encontrados. El grupo 0 siempre está vacío, por eso se usa el índice 1 para obtener el valor correcto.

En este caso la salida será algo así:

Hola mundo
Noticia de ultima hora

No siempre este tipo de etiquetas aparecen solas, sino que suelen venir acompañadas por elementos como id, class, style, u otros, que luego emplea CSS para dar estilo. Esto haría imposible que se detectara con el código actual, aunque con una leve modificación del parámetro, es posible también detectar este tipo de etiquetas:

<h1.*>(.*)</h1>

Esta expresión encontrará ambas entradas en el siguiente texto:

string text = @"<html>
        <head>
        </head>
        <body>
        <h1 id=""ultima"" class=""title"">Hola mundo</h1>
        <h1>Noticia de ultima hora</h1>
        </body>
        </html>";

Más información

Las expresiones regulares van mucho más allá de este artículo, se puede encontrar más información en los siguientes sitios (en inglés):

dijktrasalgorithmexample

Los 10 algoritmos más frecuentes que surgen en entrevistas de trabajo de programación

/ , / 0 comments

Dijkstra, Burbuja, Knapsack… Todos son términos relacionados con algoritmos de programación de algún tipo, pero también son los que surgen más frecuentemente en entrevistas de trabajo como parte de los testsque hay que superar. Que no todo es explicar cuál es tu mayor defecto o qué tal ese nivel de inglés.

En GeeksforGeeks han recopilado una lista con los diez algoritmos más frecuentes en entrevistas de trabajo. De hecho más que diez son 80 porque han listado el «top 10» de ocho temas de programación principales. Pueden servir como repaso antes de ese «momento clave» que es la entrevista – o simplemente para aprender.

Los ocho temas principales incluyen grafos, listas enlazadas, búsqueda, teoría de números, cadenas, matrices y otros. Y para cada uno de ellos se muestran los diez algoritmos más frecuentes – junto con enlaces, explicaciones acerca de por qué y cómo funcionan y normalmente algo de código de ejemplo (normalmente en C, C++, Python, Java, JavaScript o varios de ellos).

En búsquedas por ejemplo lo más habitual por la que se pregunta es algo que se resuelve mediante búsqueda binaria. También puede surgir la necesidad de comprobar la primalidad de un número entero y el Método de Fermat suele ser el más conveniente. Otras preguntas suelen estar relacionadas con las representaciones binarias de un número.

Estos consejos no son una bala de plata que sirva para superar todos los tests aunque ayudar, ayudan. Lo importante, como suele decirse es entender bien las preguntas, preguntarse a cada paso si la solución tiene sentido y hacer otro tanto al terminar. Identificar cuál de los algoritmos es el apropiado para cada problema (o si hay que utilizar otro o ingeniárselas sobre la marcha) es la clave del asunto.

Método Heap Sort: Ordenamiento método Heap Sort.php

/ , , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.

El código realiza un Ordenamiento de datos numéricos haciendo uso del Método Heapsort:

<?php
 
    function heapsort($A,$n)
    {
 
        for($k=$n-1;$k>=0;$k--)
        {
                for($i=1;$i<=$k;$i++)
                {
                        $item=$A[$i];
                        $j=$i/2;
                        while($j>0 && $A[$j]<$item)
                        {
                                $A[$i]=$A[$j];
                                $i=$j;
                                $j=$j/2;
                        }
                        $A[$i]=$item;
                }
                $temp=$A[0];
                $A[0]=$A[$k];
                $A[$k]=$temp;
        }
 
      return $A;
    }
 
    function main()
    {
 
        $VectorA=array(5,4,3,2,1);
 
        $VectorB=heapsort($VectorA,sizeof($VectorA));
 
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
 
    }
 
    main();
?>

Método de Selección: Ordenamiento método Selección.php

/ , , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.

El código realiza un Ordenamiento de datos numéricos haciendo uso del Método de Selección:

<?php
 
    function selectionsort($A,$n)
    {
        for ($i=0; $i<$n-1; $i++)
    {
              $min=$i;
              for($j=$i+1; $j<$n; $j++)
                    if($A[$min] > $A[$j])
                       $min=$j;
              $aux=$A[$min];
              $A[$min]=$A[$i];
              $A[$i]=$aux ;
        }
 
      return $A;
    }
 
    function main()
    {
 
        $VectorA=array(5,4,3,2,1);
 
        $VectorB=selectionsort($VectorA,sizeof($VectorA));
 
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
 
    }
 
    main();
?>

Método Inserción Binaria: Ordenamiento por inserción Binaria.php

/ , , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.

El código realiza un Ordenamiento de datos numéricos haciendo uso del Método de Inserción Binaria:

<?php
 
    function insercionBinaria($A,$n)
    {
            for($i=1;$i<$n;$i++)
            {
                $aux = $A[$i];
                $izq=0;
                $der=$i-1;
 
                while($izq<=$der)
                {
                    $m=(($izq+$der)/2);
                    if ($aux<$A[$m])
                        $der=$m-1;
                    else
                        $izq=$m+1;
                }
                $j=$i-1;
 
                while($j>=$izq)
                {
                    $A[$j+1]=$A[$j];
                    $j=$j-1;
                }
                $A[$izq]=$aux;
            }
 
      return $A;
    }
 
    function main()
    {
 
        $VectorA=array(5,4,3,2,1);
 
        $VectorB=insercionBinaria($VectorA,sizeof($VectorA));
 
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
 
    }
 
    main();
?>

Método Inserción Directa: Ordenamiento por inserción Directa.php

/ , , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.

El código realiza un Ordenamiento de datos numéricos haciendo uso del Método de Inserción Directa:

<?php
 
    function insercionDirecta($A,$n)
    {
 
        for ($i = 1; $i < $n; $i++)
        {
                 $v = $A[$i];
                 $j = $i - 1;
                 while ($j >= 0 && $A[$j] > $v)
                 {
                          $A[$j + 1] = $A[$j];
                          $j--;
                 }
 
                 $A[$j + 1] = $v;
        }
 
        return $A;
    }
 
    function main()
    {
 
        $VectorA=array(5,4,3,2,1);
 
        $VectorB=insercionDirecta($VectorA,sizeof($VectorA));
 
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
 
    }
 
    main();
?>

Método quick sort: Ordenamiento por método Quick Sort.php

/ , , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.

El código realiza un Ordenamiento de datos numéricos haciendo uso del Método Quicksort:

<?php
    function quicksort($A, $izq, $der )
    {
        $i = $izq;
        $j = $der;
        $x = $A[ ($izq + $der) /2 ];
    do{
        while( ($A[$i] < $x) && ($j <= $der) )
        {
            $i++;
        }
 
        while( ($x < $A[$j]) && ($j > $izq) )
        {
            $j--;
        }
 
        if( $i <= $j )
        {
            $aux = $A[$i]; $A[$i] = $A[$j]; $A[$j] = $aux;
            $i++;  $j--;
        }
 
    }while( $i <= $j );
 
    if( $izq < $j )
        quicksort( $A, $izq, $j );
    if( $i < $der )
        quicksort( $A, $i, $der );
 
        return $A;
    }
 
    function main()
    {
 
        $VectorA=array(5,4,3,2,1);
 
        $VectorB=quicksort($VectorA,0,sizeof($VectorA)-1);
 
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
 
    }
 
    main();
?>

Método shell: Ordenamiento Shell.php

/ , , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.

El código realiza un Ordenamiento de datos numéricos haciendo uso del Método Shell:

<?php
 
    function ordenamientoShell($A,$n)
    {
        for($inc = 1 ; $inc<$n;$inc=$inc*3+1);
 
      while ($inc > 0)
      {
          for ($i=$inc; $i < $n; $i++)
          {
                $j = $i;
                $temp = $A[$i];
                while (($j >= $inc) && ($A[$j-$inc] > $temp))
                {
                    $A[$j] = $A[$j - $inc];
                    $j = $j - $inc;
                }
 
                $A[$j] = $temp;
          }
 
          $inc/= 2;
      }
 
          return $A;
    }
 
    function main()
    {
        $VectorA=array(5,4,3,2,1);
        $VectorB=ordenamientoShell($VectorA,sizeof($VectorA));
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
    }
    main();
?>

Método Burbuja: Ordenamiento Burbuja.php

/ , / 0 comments

El siguiente post pertenece al topic: Métodos de Ordenamiento codificados en PHP.
El código realiza un Ordenamiento de datos numéricos haciendo uso del Método de la Burbuja:

<?php
    function burbuja($A,$n)
    {
        for($i=1;$i<$n;$i++)
        {
                for($j=0;$j<$n-$i;$j++)
                {
                        if($A[$j]>$A[$j+1])
                        {$k=$A[$j+1]; $A[$j+1]=$A[$j]; $A[$j]=$k;}
                }
        }
      return $A;
    }
    function main()
    {
        $VectorA=array(5,4,3,2,1);
        $VectorB=burbuja($VectorA,sizeof($VectorA));
        for($i=0;$i<sizeof($VectorB);$i++)
            echo $VectorB[$i]."\n";
    }
    main();
?>




    


		
		


		
	

	
	
	



							
											
			

			

			
 1  2