Divisibilidad por 3
Un numero es divisible por 3 si solo si la suma de sus dígitos es también divisible por 3.

Ejemplo
Veamos si el numero 1731564 es divisible por 3.
Según el teorema anterior, 1+7+3+1+5+6+4=27, pero 27 es divisible por 3 (27=9*3), por tanto, también 1731564 es divisible por 3.

Demostración
Para hacer la demostración formal, habría que demostrar dos cosas (ya que hablamos de una doble implicación).
1ra.
Demostraremos primeramente que si 3|n, entonces 3 divide a la suma de sus dígitos.
Sean a0, a1, a2, a3,…, ak, los dígitos de n.
Sabemos que todo numero n de k cifras, se puede escribir como:
n= a0 + a1*10 + a2*100 + … + ak * 100…0  (ej. 132=100 + 30 + 2)
luego, partimos de que 3|n (3 divide a n), y por tanto:
3| a0 + a1*10 + a2*100 + … + ak * 100…0  (planteamos la división que tenemos por dato)

*Ahora el gran truco de la demostración. Lo que hacemos es descomponer todo numero de la forma 10k como 9999…9 +1, donde el 9 se repite k veces. Luego:
3| a0 + a1*(9+1)1 + a2*(99+1) + … + ak *(999…9+1)  (descomponiendo)
3| a0 + 9a1 + a1 + 99a2 + a2 + … + 9999…9ak + ak (aplicando propiedad distributiva)
3| (a0 + a1 + a2 + a3+…+ ak) + 9a1 + 99a2 + 999a3 + … + 9999…9ak       (agrupando)
3| (a0 + a1 + a2 + a3+…+ ak) + 9(a1 + 11a2 + 111a3 + … + 1111…1ak) (sacando factor común)
Ahora utilizaremos una propiedad de divisibilidad que no se ve mucho en los libros:
Si a|b+c y a|c, entonces a|b (si a divide a b+c, y a divide a c, entonces necesariamente a|b)
Tomando:
b + c = n =  (a0 + a1 + a2 + a3+…+ ak) + 9(a1 + 11a2 + 111a3 + … + 1111…1ak)
c = 9(a1 + 11a2 + 111a3 + … + 1111…1ak)
b = (a0 + a1 + a2 + a3+…+ ak)

Tenemos por dato que 3|n,
además esta claro que 3|9(a1 + 11a2 + 111a3 + … + 1111…1ak), ya que 3|9,
por tanto utilizando la propiedad anterior, necesariamente:
3 | a0 + a1 + a2 + a3+…+ ak, que no es mas que la suma de los dígitos de n.

La segunda parte de la demostración es muy parecida a esta, pero de atrás hacia delante. Es valido aclarar que a mi no se me ocurrió esta demostración, y hay muchas formas de demostrar esta propiedad (por inducción, etc), pero esta es una bastante original. Si quieres compartir alguna otra solución o tienes alguna duda, puedes hacerlo en los comentarios.
Bonita demostración verdad?

Ahora ya puedes explicarle a quien sea el por que un numero es divisible por 3 si y solo si es divisible por la suma de sus dígitos.

No hay entradas relacionadas.

El Ipad, con un grosor de 13,4 mm y 680 gramos de peso, es más delgado y ligero que un netbook, incluye 12 nuevas e innovadoras aplicaciones diseñadas especialmente para él y gracias a la interfaz Multi-Touch hace que navegar la web o enviar emails sea una experiencia más interactiva.Entre las características del nuevo Ipad destaca procesador A4 que funciona con una frecuencia de 1 Ghz, pantalla multitáctil de 9,7 pulgadas, 16, 32 o 64 GB de memoria, Wifi compatible con 802.11n, 3G opcional, bateria que proporciona una autonomía de 10 horas, teclado virtual a tamaño casi completo, y compatibilidad con casi la totalidad de las más de 140.000 apps disponibles en la App Store. Entre los deficits del nuevo Ipad, señalar que carece de posibilidad de conectar dispositivos por USB, cambiar la batería, ver videos en Flash, asi como que no tiene funciones de teléfono ni dispone de cámara.

Apple ha confirmado que el Ipad estará disponible en Estados Unidos a finales de marzo a un precio recomendado de 499 dólares.

Más información sobre Ipad, el nuevo dispositivo táctil de Apple, desde www.apple.com. Veamos si tiene el mismo éxito del Iphone.

No hay entradas relacionadas.

Cuando creamos un elemento en Windows Form, para seleccionar cual evento queremos disparar y como lo queremos programar, solo hay que seleccionar un objeto (boton, formulario, label) que hayamos creado previamente, y en el menu Propiedades, en la parte superior seleccionamos Events, ahí salen todos los eventos asociados al objeto creado. Solo tenemos que hacer doble click, entonces ya podremos programar lo que queremos que se haga cuando se dispare el evento.

Si se fijan bien, al poner el mouse arriba de un Evento, en la parte inferior del panel de propiedades aparece una pequeña descripción sobre el evento.

Aquí les dejo un programita que hice ya hace algunos años, y les servirá de ejemplo para que vean el manejo del evento MouseMove().

Pueden descargar el código fuente aquí:
http://www.puntopeek.com/wp-content/uploads/2009/11/Broma.zip

Lo unico que hay que saber para hacer un programa de este tipo, bien sencillo, es programar el evento MouseMove() y saber que MouseMove() se activa cuando el mouse pasa por encima del objeto asociado este evento. El programa lo que hace es mover el botón de lugar cuando tratas de posicionar el mouse encima del botón, esto se hace calculando nuevas coordenadas.

Bueno, los dejo con el ejemplo, tengo que seguir trabajando en mi proyecto de Estructura de Datos (Un Módulo de Respuesta Automatizada xD). Practiquen un poco y lean sobre el Grafics en Windows Forms, porque a partir del lunes empezaré a escribir pequeño tutorial sobre como programar algun juego sencillo en C#, y estoy pensando en el Sudoku. Cualquier duda en los comentarios.

No hay entradas relacionadas.

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.

Entradas relacionadas:

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

Entradas relacionadas:

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

Entradas relacionadas:

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…

Entradas relacionadas: