Conjunto de Mandelbrot





SCREEN 12

DEFDBL A-Z

A% = 640 'Resolucion Horizontal
B% = 480 'Resolucion Vertical
M% = 200 'Numero de interaciones por punto

PMIN = -2.25 ' Plano complejo
PMAX = 0.75 'Plano complejo
QMIN = -1.5 'Plano complejo
QMAX = 1.5 'Plano complejo
CMAX% = 10000 'Nivel de detalle

DP = (PMAX - PMIN) / (A% - 1)
DQ = (QMAX - QMIN) / (B% - 1)
FOR NP% = 0 TO A% - 1
              FOR NQ% = 0 TO B% - 1
                      P = PMIN + NP% * DP
                      Q = QMIN + NQ% * DQ
                      K% = 0
                      X = 0
                      Y = 0
                      610 '
                      XN = (X * X) - (Y * Y) + P
                      Y = 2 * X * Y + Q
                      X = XN
                      K% = K% + 1
                      IF (X * X) + (Y * Y) > M% THEN C% = K%: GOTO 690
                      IF K% = CMAX% THEN C% = 0: GOTO 690
                      680 GOTO 610
                      690 PSET (NP%, NQ%), C%
             NEXT NQ%
NEXT NP%

720 A$ = INKEY$: IF A$ = "" THEN 720







1 IF x& = 0 THEN SCREEN 13 ELSE iter% = 0
2 x& = (x& + 123) MOD 64000
3 im2 = im * im
4 IF iter% THEN im = 2 * re * im + (CSNG(x& \ 320) / 100 - 1) ELSE im = 0
5 IF iter% THEN re = re * re - im2 + (CSNG(x& MOD 320) / 120 - 1.9) ELSE re = 0
6 iter% = iter% + 1
7 IF ABS(re) + ABS(im) > 2 OR iter% > 254 THEN PSET (x& MOD 320, x& \ 320), iter% ELSE GOTO 3
8 IF LEN(INKEY$) = 0 THEN GOTO 1






-----------------------------------------------------------------------------------------

SCREEN 13
WINDOW (-2, 1.5)-(2, -1.5)
FOR x0 = -2 TO 2 STEP .01
FOR y0 = -1.5 TO 1.5 STEP .01
x = 0
y = 0

iteration = 0
maxIteration = 1000

WHILE (x * x + y * y <= (2 * 2) AND iteration < maxIteration)
xtemp = x * x - y * y + x0
y = 2 * x * y + y0

x = xtemp

iteration = iteration + 1
WEND

IF iteration <> maxIteration THEN
c = iteration
ELSE
c = 0
END IF

PSET (x0, y0), c + 32
NEXT
NEXT





Probabilidad Binomial





La probabilidad binomial es una medida de la probabilidad de obtener con éxito una cierta cantidad de ocurrencias de un número total de ensayos. Por ejemplo, imagine que ha plantado guisantes que produjeron varios crías. También imagine que, a partir de pruebas anteriores, se han dado cuenta de que la probabilidad de obtener guisantes verdes de su granja es de 0,75. Ahora imagine que usted planta algunos guisantes y producen cinco descendientes. Es posible que desee averiguar la probabilidad de obtener tres guisantes.


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 ProbabilidadBinomial_I
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

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

        private static long Factorial(long x)
        {
            if (x <= 1)
                return 1;
            else
                return x * Factorial(x - 1);
        }

        private static long Combination(long a, long b)
        {
            if (a <= 1)
                return 1;

            return Factorial(a) / (Factorial(b) * Factorial(a - b));
        }

       private double ProbabilidadBinomial (int ensayos, int aciertos, double probabilidad)
        {
            double fallos = 1 - probabilidad;
            double c = Combination(ensayos, aciertos);
            double px = Math.Pow(probabilidad, aciertos);
            double qnx = Math.Pow(fallos, ensayos - aciertos);
            return c * px * qnx;
        }


Factor Primo




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 FactoresPrimosNumero_Forms
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

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

        private void button1_Click(object sender, EventArgs e)
        {
            int numero, resi, k;
            string cadena = textBox2.Text;

            numero = int.Parse(textBox1.Text);
            k = 2;

            if (!int.TryParse(textBox1.Text, out numero)) numero = -1;
            if (numero < 2)
            {
                MessageBox.Show("Numeros negativos NO. \r\n Superiores a 2 por favor");
                textBox1.Clear();
                return;
            }

            while ((numero != 1))
            {
                resi = numero % k;
                if ((resi == 0))
                {
                    cadena += (k.ToString() + " x ");
                    textBox2.Text = cadena.Remove(cadena.Length - 2);
                    numero = numero / k;
                }
                else
                {
                    k = k + 1;
                }
            }

        }

Conjunto de Mandelbrot




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 Mandel_I
{
    public partial class Form1 : Form
    {
        static double currentmaxr = 0;
        static double currentminr = 0;
        static double currentmaxi = 0;
        static double currentmini = 0;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Bitmap img = MandelbrotSet(pictureBox1, 2, -2, 2, -2);
            pictureBox1.Image = img;
        }

        static Bitmap MandelbrotSet(PictureBox pictureBox1, double maxr, double minr, double maxi, double mini)
        {
            currentmaxr = maxr;
            currentmaxi = maxi;
            currentminr = minr;
            currentmini = mini;
            Bitmap img = new Bitmap(pictureBox1.Width, pictureBox1.Height);
            double zx = 0;
            double zy = 0;
            double cx = 0;
            double cy = 0;
            double xjump = ((maxr - minr) / Convert.ToDouble(img.Width));
            double yjump = ((maxi - mini) / Convert.ToDouble(img.Height));
            double tempzx = 0;
            int loopmax = 1000;
            int loopgo = 0;
            for (int x = 0; x < img.Width; x++)
            {
                cx = (xjump * x) - Math.Abs(minr);
                for (int y = 0; y < img.Height; y++)
                {
                    zx = 0;
                    zy = 0;
                    cy = (yjump * y) - Math.Abs(mini);
                    loopgo = 0;
                    while (zx * zx + zy * zy <= 4 && loopgo < loopmax)
                    {
                        loopgo++;
                        tempzx = zx;
                        zx = (zx * zx) - (zy * zy) + cx;
                        zy = (2 * tempzx * zy) + cy;
                    }
                    if (loopgo != loopmax)
                        img.SetPixel(x, y, Color.FromArgb(loopgo % 128 * 2, loopgo % 32 * 7, loopgo % 16 * 14));
                    else
                        img.SetPixel(x, y, Color.Black);

                }
            }
            return img;

        }
    }
}



Transcribo el articulo de A.K. Devdney, en el que se desarrolla el Conjunto de Mandelbrot, publicado en la revista de Investigación y Ciencia de Enero 1988,

Articulo original en PDF:

https://www.scientificamerican.com/media/inline/blog/File/Dewdney_Mandelbrot.pdf

EL OBJETO MAS COMPLEJO DE LA MATEMÁTICA

"El conjunto de Mandelbrot cavila en silente complejidad, en el centro de una vasta lámina bidimensional de números, llamada plano complejo. Cuando a estos números se les aplica reiteradamente una cierta operación, los situados en el exterior del conjunto huyen, despavoridos, hacia el infinito. Los números del interior permanecen en él, donde danzan y vagabundean de un lado a otro. En la proximidad de la frontera, erráticos vaivenes de minuciosa coreografía, señalan el comienzo de la inestabilidad. Acontece aquí una infinita regresión de minucioso detalle, que nos deja estupefactos por su variedad, su complejidad y su insólita belleza.

El conjunto recibe su nombre en honor de Benoit Mandelbrot, investigador numerario del Centro de Investigaciones Thomas J. Watson de la IBM en Yorktown Heights, Nueva York. A partir de sus trabajos con forma geométricas, Mandelbrot ha desarrollado un campo llamado geometría fractal, estudio matemático de formas que tienen dimensión fraccionaria. En particular, la frontera del conjunto de Mandelbrot es una fractal, aunque también es mucho mas.


Agregación de Difusión Limitada - ADL // Movimiento Browniano





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 ADL_II_Forms
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        int numeroparticulas;

        private void button1_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }
       
      private void Form1_Load(object sender, EventArgs e) { }
       
        private void button2_Click(object sender, EventArgs e)
        {
            Bitmap imagen =  ADL(pictureBox1, 250, numeroparticulas);    //.Save("arbol.png");
            pictureBox1.Image = imagen;
            numeroparticulas = int.Parse(textBox1.Text);
        }
       
        static Bitmap ADL(PictureBox pictureBox1, int tamaño, int numeroparticulas)
        {
            Bitmap imagen = new Bitmap(tamaño, tamaño);
            Rectangle bounds = new Rectangle { X = 0, Y = 0, Size = imagen.Size };
            using (Graphics g = Graphics.FromImage(imagen))
            {
                g.Clear(Color.Black); //color de fondo
            }
            Random rnd = new Random();
            imagen.SetPixel(rnd.Next(tamaño), rnd.Next(tamaño), Color.White); //color de los  puntos
            Point pt = new Point(), newpt = new Point();
            for (int i = 0; i < numeroparticulas; i++)
            {
                pt.X = rnd.Next(tamaño);
                pt.Y = rnd.Next(tamaño);
                do
                {
                    newpt.X = pt.X + rnd.Next(-1, 2);
                    newpt.Y = pt.Y + rnd.Next(-1, 2);
                    if (!bounds.Contains(newpt))
                    {
                        pt.X = rnd.Next(tamaño);
                        pt.Y = rnd.Next(tamaño);
                    }
                    else if (imagen.GetPixel(newpt.X, newpt.Y).R > 0)
                    {
                        imagen.SetPixel(pt.X, pt.Y, Color.White);
                        break;
                    }
                    else
                    {
                        pt = newpt;
                    }
                } while (true);
            }
            return imagen;
        }      
    }
}


El movimiento browniano es el movimiento aleatorio que se observa en las partículas que se hallan en un medio fluido (líquido o gas), como resultado de choques contra las moléculas de dicho fluido.

Este fenómeno de transporte recibe su nombre en honor al escocés Robert Brown, biólogo y botánico. En 1827, mientras miraba a través de un microscopio a las partículas atrapadas en las cavidades dentro de un grano de polen en el agua, señaló que las partículas se movían a través del líquido; pero no fue capaz de determinar los mecanismos que provocaron este movimiento. Los átomos y las moléculas habían sido teorizadas como componentes de la materia, y Albert Einstein publicó un artículo en 1905, considerado por él como el Annus Mirabilis ("año maravilloso", en latín) donde explicó con todo detalle cómo el movimiento que Brown había observado era el resultado del polen siendo movido por moléculas de agua individuales. Esta explicación sirvió como prueba convincente de que existen los átomos y moléculas, y fue verificado experimentalmente por Jean Perrin en 1908. Perrin fue galardonado con el Premio Nobel de Física en 1926 por su trabajo sobre la estructura discontinua de la materia (Einstein había recibido el premio cinco años antes por sus servicios a la física teórica ​​con especial mención al efecto fotoeléctrico). La dirección de la fuerza de bombardeo atómico está cambiando constantemente, y en diferentes momentos, la partícula es golpeada más en un lado que en otro, lo que lleva a la naturaleza aleatoria del movimiento.

El movimiento browniano se encuentra entre los procesos estocásticos más simples, y es afín a otros dos procesos estocásticos más simples y complejos: el camino aleatorio y el teorema de Donsker. Esta universalidad está estrechamente relacionada con la universalidad de la distribución normal. En ambos casos, a menudo es la conveniencia matemática, más que exactitud de los modelos, lo que lleva al uso de la distribución normal.

Tanto la difusión como la ósmosis se basan en el movimiento browniano.


El poema científico Sobre la Naturaleza de las cosas, del romano Lucrecio (60 a. C.), incluye la notable descripción de un movimiento browniano de partículas de polvo desde los versos 113 hasta el 140. El autor presentó este hecho como prueba de la existencia de los átomos:

Observa lo que acontece cuando rayos de sol son admitidos dentro de un edificio y cómo arroja la luz sobre los lugares oscuros. Puedes ver la multitud de pequeñas partículas moviéndose en un sinnúmero de caminos... su baile es un indicio de movimientos subyacentes de materia escondidos de nuestra vista... eso origina el movimiento de los átomos en sí mismos (p.e., espontáneamente). Entonces los pequeños organismos que son eliminados del impulso de los átomos son puestos en marcha por golpes invisibles y a su vez en contra de unos diminutos cañones. Así, el movimiento de los átomos emerge gradualmente de un nivel del sentido, que estos cuerpos están en movimiento como vemos en el rayo de sol, movidos por soplos que parecen invisibles.

Sobre la naturaleza de las cosas, Lucrecio

Aunque el movimiento de mezcla de partículas de polvo es causado principalmente por las corrientes de aire, el brillo y el ajetreo de las partículas es, ciertamente, producto de la dinámica browniana

Jan Ingenhousz describió el movimiento irregular de partículas de carbón pulverizadas en la superficie del alcohol en 1785. No obstante, el descubrimiento del movimiento browniano se atribuye tradicionalmente al botánico Robert Brown en 1827. Se cree que Brown estuvo estudiando al microscopio partículas de polen de la planta Clarkia pulchella flotando en el agua. Dentro de las vacuolas de los granos de polen observó diminutas partículas con movimientos nerviosos. Al repetir el experimento con partículas de polvo, concluyó que el movimiento no se debía a que las partículas de polen estuvieran "vivas", aunque no explicó el origen del movimiento.

El primero en describir matemáticamente el movimiento browniano fue Thorvald N. Thiele en 1880, en un documento sobre el método de los mínimos cuadrados. Fue seguido independientemente por Louis Bachelier en 1900, en su tesis doctoral La teoría de la especulación, en la que se presenta un análisis estocástico de acción y opción de mercados. El modelo del movimiento browniano de las acciones de mercado es citado frecuentemente, pero Benoit Mandelbrot rechazó su aplicación al movimiento de los precios de las acciones, en parte porque son discontinuos.

Sin embargo, fue el estudio independiente de Albert Einstein en su artículo de 1905 (Über die von der molekularischen Theorie der Wärme geforderte Bewegung von in ruhenden Flüssigkeiten suspendierten Teilchen / Sobre el movimiento postulado por la teoría cinética molecular del calor de pequeñas partículas suspendidas en un líquido estacionario) en el que mostró la solución a los físicos, como una forma indirecta de confirmar la existencia de átomos y moléculas.

En esa época la naturaleza atómica de la materia aún era una idea controvertida. Einstein y Marian Smoluchowski dedujeron que, si la teoría cinética de los fluidos era correcta, entonces las moléculas de agua tendrían movimientos aleatorios. Por lo tanto, las partículas pequeñas podrían recibir un número aleatorio de impactos, de fuerza aleatoria y de direcciones aleatorias, en cortos períodos de tiempo. Este bombardeo aleatorio por las moléculas del fluido podría ser suficiente para que las partículas pequeñas se moviesen de la manera exacta que Brown había descrito. Theodor Svedberg hizo importantes demostraciones del movimiento browniano en coloides, así como Felix Ehrenhaft lo hizo con partículas de plata en la atmósfera terrestre. Jean Perrin también realizó experimentos para verificar los modelos matemáticos, y al publicar sus resultados finales se puso fin a dos mil años de disputa sobre la realidad de las moléculas y los átomos.


https://es.wikipedia.org/wiki/Movimiento_browniano



Entropía de Shannon

"El hombre más importante del que probablemente no hayas oído hablar jamás."



En el ámbito de la teoría de la información la entropía, también llamada entropía de la información y entropía de Shannon (en honor a Claude E. Shannon), mide la incertidumbre de una fuente de información.

La entropía también se puede considerar como la cantidad de información promedio que contienen los símbolos usados. Los símbolos con menor probabilidad son los que aportan mayor información; por ejemplo, si se considera como sistema de símbolos a las palabras en un texto, palabras frecuentes como «que», «el», «a» aportan poca información, mientras que palabras menos frecuentes como «corren», «niño», «perro» aportan más información. Si de un texto dado borramos un «que», seguramente no afectará a la comprensión y se sobreentenderá, no siendo así si borramos la palabra «niño» del mismo texto original. Cuando todos los símbolos son igualmente probables (distribución de probabilidad plana), todos aportan información relevante y la entropía es máxima.

El concepto entropía es usado en termodinámica, mecánica estadística y teoría de la información. En todos los casos la entropía se concibe como una «medida del desorden» o la «peculiaridad de ciertas combinaciones». La entropía puede ser considerada como una medida de la incertidumbre y de la información necesarias para, en cualquier proceso, poder acotar, reducir o eliminar la incertidumbre. Resulta que el concepto de información y el de entropía están básicamente relacionados entre sí, aunque se necesitaron años de desarrollo de la mecánica estadística y de la teoría de la información antes de que esto fuera percibido.

Claude Elwood Shannon (30 de abril de 1916 – 24 de febrero de 2001) fue un matemático, ingeniero eléctrico y criptógrafo estadounidense recordado como «el padre de la teoría de la información».

Shannon es reconocido por haber fundado el campo de la teoría de la información con la publicación Una teoría matemática de la comunicación, que supuso un hito en 1948. Es quizás igualmente conocido por haber sentado las bases de la teoría del diseño del ordenador digital y el circuito digital en 1937. Con 21 años, mientras realizaba su maestría en el Massachusetts Institute of Technology (MIT), demostró con su tesis, que las aplicaciones electrónicas de álgebra booleana podrían construir cualquier relación lógico-numérica. Shannon contribuyó asimismo al campo del criptoanálisis para la defensa de Estados Unidos durante la Segunda Guerra Mundial, con trabajos sobre el descifrado de códigos y la seguridad en las telecomunicaciones.

Claude Elwod Shannon definió una forma de medir la cantidad de información que contiene una variable aleatoria, es lo que se conoce como Entropía de Shannon y su formula es la siguiente:


Esta obra está bajo una: Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional. Autor: Ondiz Zarraga
 https://ondahostil.wordpress.com/2015/04/16/lo-que-he-aprendido-entropia-de-shannon/




                       The Man Who Turned Paper Into Pixels from Adam Westbrook on Vimeo.


La entropía definida por Shannon , referida a la teoría de la información, hace referencia a la cantidad media de información que contiene una variable aleatoria (psicológica) o, en particular, una fuente transmisión binaria. La información que aporta un determinado valor, xi, de una variable aleatoria discreta X, se define como:

I(xi) = log2(1/p(xi))

cuya unidad es el bit si se utiliza el logaritmo en base 2 (por ejemplo, cuando se emplea el logaritmo neperiano o natural se habla de nats).

La entropía o información media de la variable aleatoria discreta, X, se determina como la información media del conjunto de valores discretos que puede adoptar (también medida en bits):

H(x) = Σip(xi) •log2(1/p(xi))



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 EntropíaShannon_I
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

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

        public static double logaritmo(double num)
        {
            return Math.Log(num) / Math.Log(2);
        }
        private void button2_Click(object sender, EventArgs e)
        {

            string entrada = textBox1.Text;
            double entropia = 0;
            Dictionary<char, double> tabla = new Dictionary<char, double>();


Números Catalán del Triangulo de Pascal





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 CatalanNumberTrianguloPascal_I
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        int limite;

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

        private void button2_Click(object sender, EventArgs e)
        {
            int n = limite;

            limite = int.Parse(textBox1.Text);

            List<int> t = new List<int>() { 0, 1 };

            for (int i = 1; i <= n; i++)
            {
                for (var j = i; j > 1; j--) t[j] += t[j - 1];

                t.Add(t[i]);

                for (var j = i + 1; j > 1; j--) t[j] += t[j - 1];
                {
                    listBox1.Items.Add((((i == 1) ? "                  " : "                  ") + (t[i + 1] - t[i])) + "\r\n");
                }

            }

        }
    }
}


Número de Munchausen




Un número de Munchausen (o Münchhausen) es un número natural n el cual la suma de sus dígitos (en base 10), elevados a la misma potencia de ellos mismos es el mismo número es decir n. En otras palabras, si el número tiene la representación decimal:




Entonces:





El término fue acuñado por el ingeniero de software y matemático holandés Daan van Berkel en 2009. El nombre se debe a que cada dígito está "elevado" por si mismo, esto evoca la historia de Barón Munchausen que se elevo a si mismo hacia arriba jalando su propia coleta. Los números narcisistas siguen una regla similar, pero en el caso de los números narcisistas la potencia de los dígitos es fija, siendo elevados a la potencia del número de dígitos en el número. Esto es una explicación adicional para el nombre, dado que el Barón Münchhausen era un conocido narcisista.

Pensando rápido, posiblemente encontréis el primer número Münchhausen, el 1. Pero si seguís probando, estaréis mucho tiempo hasta encontrar el siguiente número Münchhausen. De hecho, si no os valéis de un ordenador, posiblemente pasarían días y mucho aburrimiento hasta que llegaseis al número 3435 (siempre hablando en base 10).

Estos números en muchas ocasiones se considera un grupo dentro de los números narcisistas, agrupándolos con los números de Armstrong (los que normalmente son llamados narcisistas), los números de Dudeney o los números de Friedman.

Un ejemplo es:







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 MunchausenForms_I
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        int limite;

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

Reloj / progressBar / trackBar




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 Reloj_I
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            progressBar1.Minimum = 0;
            progressBar1.Maximum = 23;
            progressBar1.Style = ProgressBarStyle.Continuous;
            progressBar2.Minimum = 0;
            progressBar2.Maximum = 59;
            progressBar2.Style = ProgressBarStyle.Continuous;
            progressBar3.Minimum = 0;
            progressBar3.Maximum = 59;
            progressBar3.Style = ProgressBarStyle.Continuous;
            trackBar1.Minimum = 0;
            trackBar1.Maximum = 23;
            trackBar2.Minimum = 0;
            trackBar2.Maximum = 59;
            trackBar3.Minimum = 0;
            trackBar3.Maximum = 59;
            timer1.Interval = 10;
            timer1.Enabled = true;
        }


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)
                {

                    do
                    {
                        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;
                    }
                }

            }
        }
    }
}


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:
  1. d es divisor común de los números a y b y
  2. 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++;
            }