Aprendiendo C#, Python, C++, A.I, BASIC...: mayo 2017

Números Lychrel

Un número de Lychrel es un número natural que no puede formar un palíndromo a través del proceso iterativo repetitivo de invertir sus dígitos y sumar los números resultantes. Este proceso es a veces llamado algoritmo-196 (en inglés 196-algorithm), a raíz del número más famoso asociado con el proceso. En base decimal, no ha sido demostrado que los números de Lychrel existan, pero algunos, incluyendo el 196, son sospechosos por motivos estadísticos y de heurística. El nombre «Lychrel» fue acuñado por Wade VanLandingham como un anagrama aproximado de Cheryl, el nombre de su novia.

A partir de un número inicial en base decimal, se realiza la suma de este y su número invertido, es decir, el número resultante de la inversión del orden en el que aparecen sus dígitos. Por ejemplo, para 124 se tiene que 124 + 421 = 545. Repitiendo el mismo proceso con los números resultantes, si alguno de ellos es un palíndromo, entonces el número inicial no es un número de Lychrel.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using IntXLib;

namespace Lychrel_IV_Forms
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button2_Click(object sender, EventArgs e)
{
Application.Exit();
}

int numeromaximo;

private void button1_Click_1(object sender, EventArgs e)
{
numeromaximo = int.Parse(textBox1.Text);
int contador = 0;
for (int i = 1; i < numeromaximo; i++)
{
IntX iteracionTotal = new IntX(i);

for (int iteracion = 0; iteracion < 51; iteracion++)
{
if (iteracion == 50)
{
listBox1.Items.Add(i.ToString() + " Lychrel");
contador++;
break;
}
iteracionTotal += ReversoNumero(iteracionTotal);
if (Palindromo(iteracionTotal.ToString()))
{
listBox2.Items.Add(i + " Palindromo");
break;
}
}
}
textBox2.Text = contador.ToString();
}

Constante de Kaprekar - 6174

El número 6174 es conocido como la Constante de Kaprekar en honor de su descubridor el matemático indio Dattatreya Ramachandra Kaprekar. Este número es el resultado de la aplicación repetida de la Operación de Kaprekar que consiste en los siguientes pasos:

Escoger cualquier número de cuatro dígitos (con limitadas excepciones, véase más abajo).

Ordenar los cuatro dígitos en orden ascendente, para obtener el minuendo de una resta.

Ordenar los mismos cuatro dígitos en orden descendente, para obtener el sustraendo de la misma resta.

Calcular el resto, restando el sustraendo del minuendo.

Si el resto no es igual a 6174, repetir los cuatro pasos anteriores, añadiendo ceros a la derecha al minuendo y a la izquierda al sustraendo, siempre que sea necesario para completar los cuatro dígitos.

Esta operación, repetida si es necesario en varias ocasiones (nunca más de siete veces), termina dando el resultado 6174. El proceso termina porque si se sigue repetiendo la secuencia de pasos, se sigue obteniendo el mismo resultado ya que 7641 – 1467 = 6174.

Por ejemplo, supongamos que partimos del número de cuatro dígitos 5342:

5432 – 2345 = 3087

8730 – 0378 = 8352

8532 – 2358 = 6174

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ConstanteKaprekar_I_Forms

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

Application.Exit();

}

private void button2_Click(object sender, EventArgs e)

{

int numero, res, aux, max2, max3, max4, max, min, ctr, u = 0, d = 0, c = 0, m = 0, max1 = 0;

string variabletemporal = textBox1.Text;

if (variabletemporal != null)

{

numero = int.Parse(variabletemporal);

if (numero > 999 && numero <= 9999)

{

res = 0;

ctr = 0;

aux = 0;

u = 0;

d = 0;

c = 0;

m = 0;

while (numero > 10)

{

res = numero % 10;

switch (aux)

{

case 0:

{

u = res;

aux++;

break;

}

case 1:

{

d = res;

aux++;

break;

}

case 2:

{

c = res;

aux++;

break;

}

numero /= 10;

}

m = numero;

max1 = u;

max2 = d;

max3 = c;

max4 = m;

Numeros de Kaprekar

En matemáticas, un número de Kaprekar (Por: Shri Dattatreya Ramachandra Kaprekar, 1905–1986, matemático Indio) es aquel entero no negativo tal que, en una base dada, los dígitos de su cuadrado en esa base pueden ser separados en dos números que sumados dan el número original. El ejemplo más simple es 9, su cuadrado es 81 y 8+1= 9. Otro ejemplo es el número 703, su cuadrado es 494209. Si separamos 494209 en dos nuevos números, 494 y 209, obtenemos que 494 + 209 = 703. De igual forma, el número 297 también es un número de Kaprekar, ya que es posible descomponer el cuadrado 2972 = 88209 en 88 y 209.

El segundo número puede comenzar por cero, pero debe ser positivo. Un ejemplo es 999, ya que 9992=998001 y se descompone en 998 y 001. Por esto mismo, el número 100 no es un número de Kaprekar, ya que 100²=10000 y se descompone en 100 + 00, pero el segundo sumando no es positivo.

Matemáticamente, sea X un entero no negativo. X es un número de Kaprekar para la base b si existen n números enteros no negativos, A y B, que satisfagan las siguientes condiciones:

0 < B < bn

X² = Abn + B

X = A + B

Los primeros números de Kaprekar en base 10 son ((sucesión A006886 en OEIS)):1, 9, 45, 55, 99, 297, 703, ...
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Kaprekar_I_Forms
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
Application.Exit();
}

ulong numeromaximo;

private void button2_Click(object sender, EventArgs e)
{
numeromaximo = ulong.Parse(textBox1.Text);
int count = 0;

foreach (ulong numeromaximo in generador(numeromaximo))
{
listBox1.Items.Add(numeromaximo.ToString());
count++;
textBox2.Text = count.ToString();
}
}

private static IEnumerable<ulong> generador(ulong max)
{
ulong next = 1;

yield return next;

for (next = 2; next <= max; next++)
{
ulong cuadrado = next * next;

for (ulong comprobar = 10; comprobar <= 10000000000000000000; comprobar *= 10)
{

if (cuadrado <= comprobar)
break;

ulong r = cuadrado % comprobar;
ulong q = (cuadrado - r) / comprobar;

if (r != 0 && q + r == next)
{
yield return next;
break;
}
}

}
}
}
}

Insertar Google Maps en una entrada

Congruencia de Zeller

La congruencia de Zeller es un algoritmo ideado por Julius Christian Johannes Zeller un sacerdote protestante alemán que vivió en el siglo XIX. Zeller observó que existía una dependencia entre las fechas del calendario gregoriano y el día de la semana que les correspondía. A raíz de esa observación, obtuvo (se dice que por tanteo), esta fórmula, en apariencia mágica, que lleva su nombre, para calcular el día de la semana de cualquier fecha del calendario.

Para el calendario gregoriano la congruencia de Zeller es:

para el calendario juliano es:

donde
h es el día de la semana (0 = sábado, 1 = domingo, 2 = lunes,...),
q es el día del mes,
m es el mes,
J es la centuria (es realidad ⌊año / 100⌋) y
K el año de la centuria (año mod 100).
Enero y febrero se cuentan como meses 13 y 14 del año anterior. Observe, que el 2 de enero de 2013, es m=13; año=2012
Es oportuno recordar que la función mod es el residuo que queda de la división de dos números.
En las implementaciones informáticas en las que el módulo de un número negativo es negativo, la manera más sencilla de obtener un resultado entre 0 y 6 es reemplazar - 2 J por + 5 J y - J por + 6 J.

Algoritmo Z(y, m, d)

Entrada: El año y, mes m (1 ≤ m ≤ 12) y día d (1 ≤ d ≤ 31).

Salida: El día de la semana.

t ← (0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4)

n ← (domingo, lunes, martes, miércoles, jueves, viernes, sábado)

if m < 3

y ← y - 1

w ← (y + ⌊y/4⌋ - ⌊y/100⌋ + ⌊y/400⌋ + tm-1 + d) mod 7

devolver nw

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Zeller_I_Forms
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();

}

string[] dias = new string[] { " Domingo ", " Lunes ", " Martes ", " Miercoles ", " Jueves ", " Viernes ", " Sabado " };

private void button1_Click(object sender, EventArgs e)
{
Application.Exit();
}

private void button2_Click(object sender, EventArgs e)
{
int dia, mes, año;
dia = int.Parse(textBox1.Text);
mes = int.Parse(textBox2.Text);
año = int.Parse(textBox3.Text);

if ((dia < 32) && (mes < 13) && (año < 10000))
{
int a = (14 - mes) / 12;
int y = año - a;
int m = mes + 12 * a - 2;
int d = (dia + y + y / 4 - y / 100 + y / 400 + (31 * m) / 12) % 7;
textBox4.Text = dias[d];

}
}
}

}

Maquina de Estados Finitos

Imaginemos un pequeño robot que recogerá diez objetos colocados al azar. Si en algún momento el robot empieza a quedarse sin batería, tendrá que ir a recoger una nueva. Si el robot se queda por completo sin batería, se muere.
Observamos los estados necesarios:

- Estado de búsqueda en el cual el robot se dirija hacia el objeto.
- Estado en el que decida cuál es el siguiente objeto a recoger.
- Estado en el cual el robot deberá ir a por una batería nueva.
- Estado en que llega a la batería y recarga energía.
- Estado en el que el robot muere por falta de energía.
- Estado en el que el robot se mueve al azar ya que no hay mas objetos que recoger.

Transiciones:

Si se encuentra en el estado de búsqueda, puede seleccionar un nuevo objeto que buscar si ya llegó al objeto buscado, o dirigirse hacia la batería si su cantidad de energía es menor a 400 unidades.
Si se encuentra en el estado en el que escoge el siguiente objeto por buscar, puede cambiar de estado. Se cambia a búsqueda cuando haya seleccionado el nuevo objeto. Si no hay más objetos para recoger, entonces se pasa al estado de movimiento aleatorio.
En el estado aleatorio, se lleva a cabo la transición hacia el esta de muerto cuando la energía en la batería llega a cero. El estado de muerto no tiene transición a ningún otro estado.
Cuando se dirige a la batería y la energía de ésta llega al valor cero, entonces también la transición es hacia el estado de muerto. Si llega a la batería antes de que esto suceda, se pasa al estado donde recarga. En el estado de recargar la batería, hay una transición hacia el estado de búsqueda, para completar el ciclo de estados finitos de nuestro robot.

Enlace de descarga del proyecto completo:

https://code.msdn.microsoft.com/Maquina-de-Estados-Finitos-94da3a96

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace MEF
{

public class Form1 : Form
{
private MainMenu mainMenu1;
private MenuItem menuItem1;
private MenuItem mnuSalir;
private MenuItem menuItem3;
private MenuItem mnuInicio;
private MenuItem mnuParo;
private Timer timer1;
private IContainer components;

// Creamos un objeto para la maquina de estados finitos
private CMaquina maquina = new CMaquina();

// Objetos necesarios
public S_objeto[] ListaObjetos = new S_objeto[10];
public S_objeto MiBateria;

public Form1()
{
//
// Necesario para admitir el Diseñador de Windows Forms
//
InitializeComponent();

//

// Inicializamos los objetos

// Cremos un objeto para tener valores aleatorios
Random random = new Random();

// Recorremos todos los objetos
for (int n = 0; n < 10; n++)
{
// Colocamos las coordenadas
ListaObjetos[n].x = random.Next(0, 639);
ListaObjetos[n].y = random.Next(0, 479);

// Lo indicamos activo
ListaObjetos[n].activo = true;
}

// Colocamos la bateria
MiBateria.x = random.Next(0, 639);
MiBateria.y = random.Next(0, 479);
MiBateria.activo = true;

maquina.Inicializa(ref ListaObjetos, MiBateria);

}

protected override void Dispose(bool disposing)
{
if (disposing)
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}

static void Main()
{
Application.Run(new Form1());
}

private void mnuSalir_Click(object sender, System.EventArgs e)
{
// Cerramos la ventana y finalizamos la aplicacion
this.Close();
}

private void mnuInicio_Click(object sender, System.EventArgs e)
{
timer1.Enabled = true;
}

private void mnuParo_Click(object sender, System.EventArgs e)
{
timer1.Enabled = false;
}

private void timer1_Tick(object sender, System.EventArgs e)
{
// Esta funcion es el handler del timer
// Aqui tendremos la logica para actualizar nuestra maquina de estados

// Actualizamos a la maquina
maquina.Control();

// Mandamos a redibujar la pantalla
this.Invalidate();
}

private void Form1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
// Creamos la fuente y la brocha para el texto
Font fuente = new Font("Arial", 16);
SolidBrush brocha = new SolidBrush(Color.Black);

// Dibujamos el robot
if (maquina.EstadoM == (int)CMaquina.estados.MUERTO)
e.Graphics.DrawRectangle(Pens.Black, maquina.CoordX - 4, maquina.CoordY - 4, 20, 20);
else
e.Graphics.DrawRectangle(Pens.Green, maquina.CoordX - 4, maquina.CoordY - 4, 20, 20);

// Dibujamos los objetos
for (int n = 0; n < 10; n++)
if (ListaObjetos[n].activo == true)
e.Graphics.DrawRectangle(Pens.Indigo, ListaObjetos[n].x - 4, ListaObjetos[n].y - 4, 20, 20);

// Dibujamos la bateria
e.Graphics.DrawRectangle(Pens.IndianRed, MiBateria.x - 4, MiBateria.y - 4, 20, 20);

// Indicamos el estado en que se encuentra la maquina
e.Graphics.DrawString("Estado -> " + maquina.EstadoM.ToString(), fuente, brocha, 10, 10);

}
}
}

Mínimo Común Multiplo

En matemáticas, el mínimo común múltiplo (abreviado m.c.m.) de dos o más números naturales es el menor número natural que es múltiplo común de todos ellos (o el ínfimo del conjunto de los múltiplos comunes). Este concepto ha estado ligado históricamente con números naturales, pero se puede usar para enteros negativos o enteros gaussianos.
El Mínimo Común Múltiplo de dos números enteros positivos a y b es un valor c entero y positivo tal que al dividir c/a y c/b, el resto es 0, y además no existe otro número menor que c que cumpla esta condición.
El mínimo común múltiplo es el menor de todos los múltiplos comunes de varios números, excluido el cero.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MCM_I_Forms
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

int numero1, numero2, minimo, mcm, mcd;
private void button2_Click(object sender, EventArgs e)
{
Application.Exit();
}

private void button1_Click(object sender, EventArgs e)
{
numero1 = int.Parse(textBox1.Text);
numero2 = int.Parse(textBox2.Text);
minimo = Math.Min(numero1, numero2); //Seleccionamos el menor
mcm = 0; //Variable para el resultado
for (int i = 1; i <= minimo; i++) //Ciclo para las iteraciones
{
//Condicion que comprobara si el numero corresponde
//a la iteracion es el mcd

Maximo Común Divisor

Se define el máximo común divisor (MCD) de dos o más números enteros al mayor número entero que los divide sin dejar resto.

Un número entero d se llama máximo común divisor (MCD) de los números a y b cuando:

d es divisor común de los números a y b y
d es divisible por cualquier otro divisor común de los números a y b.

Los tres métodos más utilizados para el cálculo del máximo común divisor de dos números son:

Por descomposición en factores primos

El máximo común divisor de dos números puede calcularse determinando la descomposición en factores primos de los dos números y tomando los factores comunes elevados a la menor potencia, el producto de los cuales será el MCD.

En la práctica, este método solo es operativo para números pequeños tomando en general demasiado tiempo calcular la descomposición en factores primos de dos números cualquiera.

Usando el algoritmo de Euclides

Un método más eficiente es el algoritmo de Euclides, que utiliza el algoritmo de la división junto al hecho que el MCD de dos números también divide al resto obtenido de dividir el mayor entre el más pequeño.

El algoritmo de Euclides es un método antiguo y eficaz para calcular el máximo común divisor (MCD). Fue originalmente descrito por Euclides en su obra Elementos. El algoritmo de Euclides extendido es una ligera modificación que permite además expresar al máximo común divisor como una combinación lineal. Este algoritmo tiene aplicaciones en diversas áreas como álgebra, teoría de números y ciencias de la computación, entre otras. Con unas ligeras modificaciones suele ser utilizado debido a su gran eficiencia.

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace MCD_I_Forms

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

int numero1, numero2, a, b, resultado;

private void button2_Click(object sender, EventArgs e)

{

Application.Exit();

}

private void button1_Click(object sender, EventArgs e)

{

//Algoritmo de Euclides

//Seleccionamos el mayor y el menor para asignarlos

//a las variables a y b respectivamente

numero1 = int.Parse(textBox1.Text);

numero2 = int.Parse(textBox2.Text);

a = Math.Max(numero1, numero2);

b = Math.Min(numero1, numero2);

do //ciclo para las iteraciones

{

resultado = b; // Guardamos el divisor en el resultado

b = a % b; //Guardamos el resto en el divisor

a = resultado; //El divisor para al dividendo

}

while

(b != 0);

textBox3.Text = resultado.ToString();

}

Números Amigos - II

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace NumerosAmigos_II_Forms
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

int i, numero1, numero2, s1 = 0, s2 = 0;
string r = "";
private void button2_Click(object sender, EventArgs e)
{
Application.Exit();
}

private void button1_Click(object sender, EventArgs e)
{
numero1 = int.Parse(textBox1.Text);
numero2 = int.Parse(textBox2.Text);

i = 1;
while (i <= numero1 / 2)
{
if (numero1 % i == 0)
{
s1 += i;
}
i++;
}

Números Amigos

Tomemos por ejemplo el número el número 284, que se puede escribir como la multiplicación de los números primos 71 y 2 de la siguiente forma… 284 = 71 x 2 x 2 = 71 x 2 al cuadrado. Así, es fácil de calcular que los divisores del número 284 (sin contar el propio número), son {1, 2, 4, 71, 142}, cuya suma es

1 + 2 + 4 + 71 + 142 = 220.

Si ahora cogemos el número que nos ha salido, 220, y buscamos sus divisores, como 220 = 11 x 5 x 2 x 2, entonces estos son {1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110}, y la suma de estos es
1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284,
precisamente el primer número. Por este motivo, se dice que los números 220 y 284 son números amigos. Es decir, dos números son amigos si la suma de los divisores del primero (sin contar al número) es igual al segundo, y viceversa.

Este par de números amigos (220, 284) ya era conocido por los pitagóricos, quienes les atribuían propiedades místicas. En general, en la antigüedad se pensaba que estos números tenían poderes místicos, y eran utilizados en textos religiosos y de magia, en particular, en relación al amor y la amistad. Los astrónomos griegos los incorporaron en sus horóscopos, talismanes y amuletos.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace NumerosAmigos_Forms_I
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
int numeromaximo;

private void button2_Click(object sender, EventArgs e)
{
Application.Exit();
}

private void button1_Click(object sender, EventArgs e)
{

listBox1.Items.Clear();
int[] sumas = new int[numeromaximo];

for (int i = 1; i < sumas.Length; i++)
sumas[i] = SumaMultiplos(i);

for (int j = 1; j < sumas.Length; j++)
{
int v1 = sumas[j];
if (v1 > 1 & v1 < sumas.Length)
{
int v2 = sumas[v1];
if (v2 == j && v1 > v2)
listBox1.Items.Add(v2.ToString() + " <--> " + v1.ToString());
}
}
}