Veamos como invertir un string de tres formas distintas. Por ejemplo, si tenemos el string “puntopeek”, el método devolvería “keepotnup”.

Veamos el primer ejemplo, es el que casi todos conocemos, y es muy fácil de implementar, vamos recorriendo la palabra desde el ultimo caracter hasta el primero y vamos guardando cada letra en un nuevo string, que es el que devolverá el método. El código sería algo así:

public string Invertir(string s)
{
string aux = "";
 
//Recorremos el string en orden inverso
for (int i = s.Length - 1; i >= 0; i--)
aux += s[i];
 
//retornamos la nueva cadena
return aux;
}

Otra opción (pero hay que conocer que es una pila), es ir guardando cada letra en una pila (stack), y luego cuando esten todas las letras las sacamos de la pila. Noten que en esta estructura, el primer elemento que entra, es el último en salir, por eso nos sirve también para invertir un string. El código sería este:

public string Invertir2(string s)
{
//Declaramos una pila usando genericidad.
//Esto se puede hacer con el framework 2.0
Stack stack = new Stack();
 
//Recorremos el string y vamos metiendo en la pila
//cada caracter
for (int i = 0; i < s.Length; i++)
stack.Push(s[i]);
 
string aux = "";
 
//Vamos sacando de la pila los caracteres y los
//ponemos uno a uno en un nuevo string
for (int i = 0; i < s.Length; i++)
aux += stack.Pop();
 
return aux;
}

Ahora veremos la versión recursiva del problema. Si lo analizan paso a paso, verán que hace practicamente lo mismo que Invertir2. Como verán, este método no necesita almacenar ningun caracter, ni copiar, la recursividad se encarga de todo. En realidad la recursividad funciona como una pila (Invertir2) pero no hay que declarar variables ni nada de eso. A veces algunos métodos recursivos parecen mágicos, pero una vez dominemos esta técnica dominaremos el arte de programar. Al menos lo esencial. Veamos el código:

public string Invertir3 (string s, int lenght)
//El parametro lenght es el tamaño del string s
{
//Condicion de parada
if (lenght == 1)
return s;
else
//Llamado recursivo
return Invertir3 (s.Substring(1, s.Length - 1), lenght - 1)
+ s[0].ToString();
}

Para que se den cuenta de lo que hace el método, es necesario que le hagan un debug paso a paso, y vayan viendo como se transforman las variables locales. Si tienen alguna otra solución de como Invertir un string pueden ponerla en los comentarios. Y hasta aquí este post, espero escribir un poco más seguido, pero estoy con muchos proyectos en la universidad y mucho trabajo. Han oido hablar del WinZip o el WinRar? Proximamente estaremos hablando del Algoritmo de Huffman, que se utiliza mucho en el compactación de texto y archivos.

En este post trataré de explicar de la forma más sencilla posible, lo que es la herencia en programación, y pondré algunos ejemplos al final para ver si se llevan la idea, aunque seguro se quedan con algunas dudas, ya que es un concepto fácil de entender, pero difícil de aplicar en programación… después hablaremos entonces de lo que es la encapsulación y el polimorfismo

Por definición, la herencia no es más que la capacidad de un objeto de heredar las características de otro. Bueno, en programación, la herencia es la capacidad de una clase de heredar los métodos, las variables y las propiedades de otra (los constructores no se heredan). Esto permite ahorrar código, ya que varias funcionalidades no tendríamos que implementarlas nuevamente.

Una clase que herede de otra, puede usar los métodos, las propiedades o las variables de la clase padre. También se puede redefinir o modificar los métodos y propiedades, usando algunas palabras reservadas para esto, creando así un nuevo comportamiento del objeto. Una condición necesaria para que una clase herede de otra, es que la clase hija (la que hereda), debe poder usarse donde se use la clase padre (de la cual va a heredar). Si hay al menos un caso donde se puede usar la clase padre, y no se puede usar la clase hija, la herencia no tiene sentido.

En C#, una clase solo puede heredar de otra (por algunas razones difíciles de explicar). O sea, una clase no puede heredar de varias clases a la vez. Para que una clase herede de otra nada más hay que ponerle ‘:‘ después de su declaración, y seguido poner el nombre de la clase de la que se quiere heredar.

Ejemplo:

class Circulo: Figura
{
    // Implementación de la clase
}

Si una clase hija tiene un constructor que recibe los mismos parámetros que un constructor de la clase padre, y este constructor cumple las mismas funciones, que en la clase padre, el de la clase padre puede ser llamado desde la clase hija poniendo después de la declaración del constructor en la clase hija : y después la palabra reservada base. Dentro de los paréntesis van los parámetros del constructor base, (también veremos un ejemplo).

También es importante saber que si una clase hereda de otra, que a su vez hereda de otra, esta clase hereda también de la clase más arriba.

Por ejemplo, si un cuadrilátero es una figura y un paralelogramo es un cuadrilátero, entonces un paralelogramo es una figura…

Para que una clase padre permita que uno de sus métodos sea redefinido por sus clases herederas (las que heredan de ella) este método debe ser declarado usando la palabra reservada virtual, y cuando la clase hija vaya a redefinirlo, debe declararlo usando la palabra reservada override.

Ejemplo:

public <strong>virtual</strong> void Método()
//declaración del método en la clase Padre
{
//aquí va el codigo
}
 
public override void Método()
//declaración del método en la clase Hijo
{
//nuevas instrucciones
}

Si una clase hijo quiere redefinir un método de una clase padre, y este no fue declarado virtual en la clase padre, entonces hay que poner la palabra reservada new en la declaración del método.

Ejemplo:

public void Método()
//declaración del método en la clase Padre
{
   //aquí va el codigo
}
 
public new void Método()
//declaración del método en la clase Hijo
{
   //nuevas instrucciones
}

Ejemplo de herencia:

public class Hijo:Padre
{
 
//la clase Hijo hereda de la clase Padre
public Hijo(int n):base(n){}
}

El constructor de la clase Hijo que recibe como parámetros un entero llama al constructor de la clase Padre que recibe un entero pasándoselo como parámetro.

Ahora veremos un ejemplo real donde se vea la importancia de este importante mecanismo. Imaginen, que queremos tener algunas figuras geométricas, poder calcular el area, perimetro, moverlas en un plano, etc. Pero nos damos cuenta enseguida, que todas las figuras tienen area y perímetro, solo que se calculan de diferentes formas. Todas se pueden ocultar, mostrar y mover de igual forma, no? Veamos ya el código, para que sigan esta idea:

Antes de pasar al código, hay que definir que una jerarquía de clases es un grupo de clases, que heredan unas de otras, donde existe una clase base de la cual heredan todos los integrantes de la jerarquía, en este caso, la clase base es la clase figura.

//Declaramos la clase padre, de la que todas las figuras heredarán
//Es abstracta porque tendrá algunos metodos abstractos
 
public abstract class Figura
{
//Usamos <strong>protected,</strong> para que solo tengan acceso
//a estas variables, las clases que heredan de ella
protected int x,y;
protected Control control;
protected Pen myPen;
protected bool visible;
 
//Un constructor por defecto para todas las figuras
public Figura(int x, int y, Color color, Control control)
{
//Validar parametros
this.x = x;
this.y = y;
this.control = control;
myPen = new Pen(color,4);
 
}
public abstract void Muestra();
public abstract int Area();
public virtual void Oculta()
{
Color temp = myPen.Color;
myPen.Color = control.BackColor;
Muestra();
myPen.Color = temp;
visible = false;
}
public virtual void Traslada(int plusX, int plusY)
{
   if(visible)
   {
      Oculta();
      x += plusX;
      y += plusY;
      Muestra();
   }
   else
   {
      x += plusX;
      y += plusY;
   }

Ahora veremos el código de otras dos figuras en concreto que heredarán de la clase figura, un circulo y un rectángulo.

public class Circulo:Figura
{
//Vemos que en esta clase solo hay que declarar
//una variable
protected int radio;
//Este constructor tendrá todos los parámetros
//por defecto y un radio porque es un circulo
public Circulo(int x, int y, Color miColor, Control miControl,
 int radio)
:base(x,y,miColor,miControl)
{
   //Validacion
   this.radio = radio;
}
//Ahora hay que programar como se mostrará la figura
public override void Muestra()
{
   Graphics g = control.CreateGraphics();
   g.DrawEllipse(myPen,x-radio,y-radio,radio*2,radio*2);
   visible = true;
}
 
//Decimos como se calcula el area en este caso
public override int Area()
{
   return Math.PI * Math.PI * radio;
}
 
//Le podemos añadir otro método independiente
public int Perimetro()
{
    return 2 * Math.PI * radio;
}
}
 
//Esta clase también heredará de figura
public class Rectangulo:Figura
{
   protected int ancho,alto;
 
public Rectangulo(int x, int y, Color miColor, Control miControl, 
int ancho, int alto)
:base(x,y,miColor,miControl)
{
   //Validar
   this.ancho = ancho;
   this.alto = alto;
}
//Redefinimos como mostrar la figura
public override void Muestra()
{
   Graphics g = control.CreateGraphics();
   g.DrawRectangle(myPen,x,y,ancho,alto);
   visible = true;
}
//Redefinimos como calcular el area
public override int Area()
{
   return alto * ancho;
}
}

Bueno, hasta aquí este pequeño tutorial sobre herencia en C#, próximamente estaremos hablando sobre polimorfismo, y después de encapsulación. Cualquier duda en los comentarios. Hasta la próxima

Primero veremos y comentaremos el algoritmo que nos permite saber cuantas combinaciones posibles se pueden hacer con ciertas letras.

Veamos el código:

public static void Combina(string s)
{
        //Iniciamos este array auxiliar para
        //marcar los caracteres que ya combinamos
	bool []marcas = new bool[s.Length];
        //Llamamos al método recursivo
	Combina(s, "", marcas);
}
 
static void Combina(string original, string combinado, bool[]marcas)
{
        //Imprimimos la combinación si ya cambiamos
        //todas las letras una vez
	if(original.Length == combinado.Length)
		Console.WriteLine(combinado);
 
	for(int i = 0; i < marcas.Length; i++)
	{
           //Vemos si está marcada para no volverla a combinar
	   if(!marcas[i])
	   {
                //Marcamos el caracter que vamos a combinar
		marcas[i] = true;
                //Invocamos al metodo recursivo añadiendo
                //un caracter al string que combinamos
		Combina(original, combinado + original[i], marcas);
                //Desmarcamos el caracter para poder usarlo
                //en otras combinaciones
		marcas[i] = false;
	   }
	}
}

Como ven es un algoritmo muy sencillo, y no tan largo, donde usamos la técnica de backtracking, o vuelta atrás, que vimos hace un tiempo en este post. Espero les halla servido de ayuda este problemita, con esto podrá por ejemplo, saber de cuantas formas posibles se pueden combinar las letras a, n y c.

Si hacemos algo así:

Combina("abc");
Console.ReadLine();

esto es lo que devolvería el programa:

abc
acb
bac
bca
cab
cba

Ya se encargarán ustedes de buscarle las aplicaciones que lleva, también pueden tratar de hacer este algoritmo un poco más eficientes, piensen un poco en el como…

En el proximo post, veremos entonces todas las permutaciones que podemos hacer para descomponer un número en sumandos.

dudas=> comentarios

En un constructor, es donde se construye un objeto del tipo de la clase, es donde se inicializan las variables, se verifica que sus valores sean admisibles, y se le asignan valores a estas. Una clase puede contener varios constructores, estos se deben diferenciar en la cantidad de
parámetros, o en el tipo de los parámetros que reciben. Los constructores no se heredan, pero pueden ser llamados desde clases herederas usando la palabra reservada base y pasándole los parámetros que recibe. Esto lo veremos un poco más adelante cuando hablemos de herencia y polimorfismo, que son las bases de la programación orientada a objetos (POO).

Para declarar un constructor de una clase, se usa la siguiente sintaxis:

<modificador de visibilidad> <nombre de la clase a la que pertenece> (parámetros){instrucciones}

Ejemplo:

public class Auto
{
string marca;
int modelo;
Color color;
public Auto(){} //constructor por defecto
 
//Otro constructor
public Auto(string marca)
{
this.marca= marca;
}
//Otro constructor al que le pasamos todos los datos
public Auto(string marca, int modelo, Color color)
{
this.modelo = modelo;
this.color = color
this.marca= marca;
}

Nótese que los constructores se diferencian en la cantidad de parámetros o en el tipo de estos. Pero el constructor es uno solo, pero con varias sobrecargas, de modo que puedes elegir después como quieres crear un auto, dependiendo de los datos que tengas o no… además puedes crear  propiedades y métodos propios de una clase, pero eso lo veremos en el proximo post. Ahora  para crear un nuevo auto, o sea, una instancia de la clase Auto, podemos hacerlo de tres formas:

Auto miAuto = new Auto();
Auto ford = new Auto("Ford Explorer");
Auto audi = new Auto("Audi", 404, Color.Red);

Por ahora practiquen, ya veremos un poco más adelante todo lo que podemos y se nos permite hacer detro de las clases. Si tienen duda, comentarios…

Un string es una cadena de caracteres, y hay que saber dominar todos estos caracteres y hacer con ellos lo que nosvenga en gana. La clase String, nos da bastante ayuda, ya que trae algunos métodos que nos hacen la vida mucho más fácil a todos. Ahora explicaré los más importantes:

Métodos fundamentales

public char this[int index] {get;}
Devuelve el caracter de la posición especificada de la cadena.
 
public int Length {get;}
Devuelve la longitud de la cadena(cantidad de caracteres
que contiene) empezando a contar desde 1.
 
public string Insert(int startIndex,string value);
Inserta la cadena especificada a partir de la posición dada.
 
public string Remove(int startIndex,int count);
Elimina el número especificado de caracteres a partir de la
posición dada.
 
public string[] Split(params char[] separator);
Busca las subcadenas contenidas dentro de la cadena,
delimitándolas por los separadores que se le especifiquen,
y las copia a un arreglo de cadenas.
 
public string Substring(int startIndex);
Devuelve la subcadena contenida a partir de la posición
especificada.
 
public string Substring(int index, int length);
devuelve la subcadena que empieza a partir del índice
específico, y tiene la longitud indicada).

Ahora veamos un ejemplo donde se usan algunos de estos métodos.

Invertir una cadena. O sea si invocamos al método Invierte (”puntopeek”), imprimiría en pantalla la palabra al reves, keepotnup.

Veamos ahora el código de este primer ejemplo:

public static void Invierte(string s)
 {
 Stack pila = new Stack();
//Guardamos cada caracter en la pila
 foreach(char ch in s)
    pila.Push(ch);
//Declaramos una nueva cadena
 string aux = "";
//ahora vamos poniendo en aux, cada caracter, como
//usamos una pila, nos quedaría la palabra invertida
 while(pila.Count>0
    aux += pila.Pop().ToString();
//Imprimimos en consola la palabra invertida
 Console.WriteLine(aux);
 }

Y hasta aquí este pequeño manual sobre la clase string y sus métodos, si quieren compartir algún otro ejemplo o les quedó alguna duda, usen los comentarios

Bueno, de la mano de Anieto2k.com tenemos esta recopilación de 4 manuales para crear tu primer theme para wordpress, incluyendo el suyo propio (muy bueno).

Este es el tutorial oficial de wordpress (inglés) para diseñar templates. Nos da algunos buenos consejos y sobre todo se explica muy bien la estructura que debe tener un theme de wordpress.

Si no dispones de mucho tiempo puedes echarle un vistazo a este post de Maestros del Blog en los que nos dan algunas buenas ideas para personalizar nuestra plantilla.

Para los que tenga conexión rápida (yo no lo pude ver), pueden ver este videotutorial en Ayuda Wordpress, que según he leído parece estar muy bueno y concreto, aunque un poco largo….

Y por último, les dejo este sitio, que es el que casi siempre visito cuando busco inspiración para mis diseños, aunque por alguna extraña razón mis diseños nunca son tan buenos, será porque soy programador, dicen que no tenemos buen gusto.

Que día de la semana cae el 20 de abril del 2020?

Que día de la semana será el 12 de agosto del 2011?

Estas respuestas sin la ayuda de la computadora solo algunos eruditos pueden responderlas (yo conozco a uno). El problema no es tan sencullo como dividir y hallar restos de división.

Primero hay que buscar una forma de guardar cuantos días tiene cada mes, teniendo en cuenta claro, si el año es bisiesto o no…

Recuerden que un año es bisiesto si es divisible entre 400 ó es divisible entre 4 y no entre 100.

Bueno, vamos a hacer un programa de consola, que primero le pida al usuario que entre una fecha válida, con su día, mes y año y luego imprimiremos en consola que día de la semana será o fue la fecha recibida.

Vamos al código:

using System;
 
namespace DiaDeLaSemana
{
   class Class1
   {
      //Esta es la aplicación de entrada
      static void Main()
      {
         while(true)
	 {
		//Pedimos que entre la fecha y validamos que
                //los datos sean correctos
                Console.WriteLine("Escribe una fecha"+'\n');
		Console.Write("Dia: ");
		int d = int.Parse(Console.ReadLine());
		if(d<=0) break;
		Console.Write("Mes: ");
		int m = int.Parse(Console.ReadLine());
		if(m<=0) break;
		Console.Write("Año: ");
		int a = int.Parse(Console.ReadLine());
		if(a<=0) break;
                //Creamos un array con los días de la semanas
		string[] days = {"Domingo", "Lunes", "Martes",
                "Miercoles", "Jueves", "Viernes", "Sabado"};
           //Esta es la respuesta, usando el método DayOfWeek()
	   Console.WriteLine("Ese dia es "+days[DayOfWeek(d,m,a)]);
	 }
    }
 
    public static int DayOfWeek(int day, int month, int year)
    {
	int[] mesCode = {0,6,2,2,5,0,3,5,1,4,6,2,4};
     int result = year%100 + (year%100)/4 + day + mesCode[month];
 
	if(year/100==17) result += 5;
	else if(year/100==18) result += 3;
	else if(year/100==19) result += 1;
	else if(year/100==20) result += 0;
	else if(year/100==21) result += -2;
	else if(year/100==22)  result += -4;
 
        //Vemos si es bisiesto y quitamos un día si
        //el mes es enero o febrero
	if(EsBisiesto(year) && (month==1 || month==2))
	    result += -1;	
 
        //Esto devuelve un número entre 0 y 7
        //que nos dá el día de la semana
	return result%7;
    }
 
    //Método para saber si un año es bisiesto
    private static bool EsBisiesto(int a)
    {
	return (a%4==0 && a%100!=0) || a%400==0;
    }
}
}

Interesante verdad? Pues ya saben algo nuevo, si quieren este método puede ser un poco más elegante y con menos código, piensen en alguna otra solución y la discutimos en los comentarios.

'\n'