Mostrando entradas con la etiqueta calculo. Mostrar todas las entradas
Mostrando entradas con la etiqueta calculo. Mostrar todas las entradas

lunes, 21 de julio de 2025

De la Ruleta al Calculo El Economista que Desafio a la Loteria y Gano 14 Veces

 La lotería es, para la mayoría, un juego de azar puro, una pequeña esperanza frente a probabilidades astronómicas. Sin embargo, para Stefan Mandel, un economista rumano-australiano, no era cuestión de suerte, sino de cálculo y estrategia. Su historia es una leyenda en el mundo del juego: un hombre que, utilizando las matemáticas y la organización, logró ganar el premio gordo de la lotería no una, ni dos, ¡sino 14 veces!

El titular "De la Ruleta al Cálculo: El Economista que Desafió a la Lotería y Ganó 14 Veces" resume la fascinante travesía de Mandel, quien transformó un sistema diseñado para el azar en un negocio rentable, antes de que las leyes cambiaran para detenerlo.



El Método Mandel: Una Fórmula Basada en las Matemáticas

Stefan Mandel desarrolló su método en la década de 1960 en Rumanía, buscando una forma de escapar del régimen comunista y mejorar su vida. Su estrategia, que él mismo afirmó que un estudiante de bachillerato podría entender, se basaba en la "condensación combinatoria" y seguía una serie de pasos clave:

  1. Calcular el Número Total de Combinaciones Posibles: En cualquier lotería, el primer paso es determinar cuántas combinaciones únicas de números son posibles. Por ejemplo, en una lotería donde se eligen 6 números del 1 al 40, hay 3.838.380 combinaciones.

  2. Identificar Loterías con el Premio Gordo Suficientemente Grande: Mandel buscaba sorteos donde el premio mayor (bote) fuera al menos tres veces superior al coste total de comprar todas las combinaciones posibles. Esto aseguraba un beneficio neto después de cubrir todos los gastos y pagar a los inversores.

  3. Recaudar Fondos para la Compra Masiva de Boletos: Este era el paso más crucial y complejo. Mandel no podía comprar millones de boletos solo. Formó consorcios de inversores, convenciendo a amigos y, más tarde, a miles de personas para que aportaran capital. En su victoria más famosa en la lotería de Virginia, llegó a reunir a 2.524 inversores.

  4. Adquirir Todas (o Casi Todas) las Combinaciones Posibles: Una vez que el bote era suficientemente grande, el equipo de Mandel procedía a comprar masivamente boletos que cubrieran cada combinación posible. En algunos casos, lograron cubrir hasta el 90% o más de las combinaciones. En la lotería de Virginia, compraron 6.4 millones de los 7 millones de combinaciones posibles.

  5. Imprimir los Boletos y Entregarlos: En la época de las victorias de Mandel (años 80 y principios de los 90), algunas loterías permitían a los compradores imprimir los boletos en casa, lo que facilitaba la logística de manejar millones de combinaciones. Luego, estos boletos debían ser entregados a los distribuidores autorizados de lotería.

  6. Cobrar el Premio y Repartir las Ganancias: Una vez que se obtenía el premio gordo (lo cual estaba casi garantizado si se compraban suficientes combinaciones), Mandel y su equipo se encargaban de cobrarlo y distribuir las ganancias entre los inversores, quedándose con un porcentaje.

Victorias Notorias y Consecuencias Legales

Mandel aplicó su método con éxito en varias ocasiones, primero en su natal Rumanía (dos veces) y luego en Australia (doce veces). Sin embargo, su victoria más sonada fue en la Lotería de Virginia, Estados Unidos, en 1992, donde su consorcio ganó un premio de 27 millones de dólares, además de 900.000 dólares en premios secundarios. Esta victoria masiva atrajo la atención del FBI y la CIA, quienes lo investigaron, pero no encontraron ninguna irregularidad, ya que su método era legal en ese momento.

Las repetidas victorias de Mandel y su "hackeo" del sistema llevaron a que varios países cambiaran sus leyes de lotería. Las autoridades australianas fueron las primeras en modificar las regulaciones, y posteriormente, estados en EE. UU. y otros lugares implementaron restricciones. Hoy en día, el método de Mandel es prácticamente imposible de replicar legalmente, ya que la mayoría de las loterías tienen límites en la cantidad de boletos que una persona o grupo puede comprar, y la impresión masiva de boletos en casa ya no está permitida.

Un Legado de Ingenio y Controvertida Estrategia

Stefan Mandel es una figura controvertida. Para algunos, es un genio matemático que supo explotar las vulnerabilidades de un sistema. Para otros, su estrategia era una forma de "engañar" al espíritu de la lotería, diseñada para el disfrute individual y no para el beneficio de un consorcio. A pesar de las investigaciones y un intento fallido de lanzar su propia lotería en Gibraltar (que le llevó a prisión en Israel por fraude), Mandel se retiró y, según entrevistas de 2016, vivía en una casa en una playa remota en el Pacífico Sur.

La historia de Stefan Mandel es un fascinante estudio de caso sobre cómo el pensamiento lateral y la aplicación rigurosa de principios matemáticos pueden desafiar las probabilidades, incluso en juegos de azar masivos. Nos recuerda que, a veces, la suerte no es tan aleatoria como parece, y que la ingeniosidad humana puede encontrar patrones incluso donde la mayoría solo ve caos.

lunes, 14 de julio de 2025

¿Sobrevivirán los Programadores a la Era de la IA? Desmitificando el Futuro de la Informática

 En un panorama tecnológico dominado por la inteligencia artificial, muchos se preguntan si las carreras en informática están destinadas a la obsolescencia. Sin embargo, este artículo argumenta que la realidad es mucho más compleja y que, lejos de desaparecer, la informática se vuelve aún más crucial en este nuevo mundo.

El autor desafía la idea popular de que la IA reemplazará a los informáticos, señalando que esta visión a menudo proviene de fuera del sector. Si bien la IA puede automatizar ciertas tareas, como la escritura de código, la informática abarca un espectro mucho más amplio que incluye la arquitectura de sistemas, el diseño de infraestructuras digitales, la ciberseguridad, la verificación de sistemas y la creación de nuevos lenguajes de programación. Estas áreas requieren un razonamiento y una comprensión contextual que la IA actual no posee.

La IA debe ser vista como una herramienta que aumenta la productividad de los informáticos, no como un sustituto. Puede ayudar a resumir información y generar contenido, pero carece de la capacidad de diagnosticar interrupciones complejas, reescribir código para tecnologías emergentes o diseñar infraestructuras críticas.

El artículo destaca diez tareas específicas donde la IA no puede reemplazar a los humanos sin una supervisión altamente especializada, incluyendo la adaptación de algoritmos financieros, la creación de arquitecturas energéticamente eficientes, la auditoría de sistemas médicos basados en IA, el diseño de plataformas para validar correos electrónicos, el desarrollo de la próxima generación de IA segura y ética.

La informática está en constante evolución, y la IA depende de ella para su propio desarrollo. En lugar de desalentar a las nuevas generaciones, es crucial fomentar su formación en informática, ya que el conocimiento técnico sigue siendo la clave para construir, controlar y mejorar el mundo digital que nos rodea. Al igual que durante la Revolución Industrial, quienes entiendan y dominen la tecnología tendrán un futuro asegurado.

Vibe coding o cómo crear una app sin tener ni idea de programación:  ¿alucinación de

Lecturas Relacionadas:

Fuente Original:

Fuente Original: https://es.gizmodo.com/lo-que-muchos-no-te-cuentan-sobre-la-ia-y-la-informatica-por-que-el-futuro-aun-necesita-programadores-2000179455 

lunes, 3 de junio de 2019

Ejemplo completo de Matrices en C

A continuación, os pongo el ejemplo que se me ha ocurrido más completo sobre gestión de Matrices en C que reúne los ejemplos que he ido poniendo anteriormente.




#include <stdio.h>;
#include <stdlib.h>;


void Ingresa_Matriz (int m[3][3], int f, int c);
void Utiliza_Matriz (int m[3][3], int f, int c);
void Visualiza_Matriz (int m[3][3], int f, int c);
void Rota_Matriz_D (int m[3][3], int f, int c);
void Rota_Matriz_I (int m[3][3], int f, int c);
void Multiplica_Matriz (int m[3][3], int f, int c, int cf, int *m0, int *m1, int *m2);

int main () {
    char ingresa;
    int m[3][3], cf = 0, direccion = 0, f = 0, c = 0;
    int m0, m1, m2;
    printf ("Deseas ingresar Matriz o utiliza la maqueta &lt;I/M&gt;: ");
    scanf ("%c",&amp;ingresa);
    if (ingresa == 'i') {
        Ingresa_Matriz(m, f, c);
    } else {
        Utiliza_Matriz(m, f, c);
    }
    Visualiza_Matriz(m, f, c);
    printf ("\nDeseas rotar la matriz a la derecha &lt;1&gt; o a la izquierda &lt;0&gt;: ");
    scanf ("%d",&amp;direccion);
    if (direccion == 1) {
        Rota_Matriz_D (m, f, c);
    } else {
        Rota_Matriz_I (m, f, c);
    }
    Visualiza_Matriz(m, f, c);
    printf ("\n¿Quieres multiplicar las filas (1) o las columnas (0)?: ");
    scanf ("%d",&amp;cf);
    Multiplica_Matriz(m, f, c, cf, &amp;m0, &amp;m1, &amp;m2);
    if (cf == 1) {
        printf ("\nMultiplicacion Fila 0: %d",m0);
        printf ("\nMultiplicacion Fila 1: %d",m1);
        printf ("\nMultiplicacion Fila 2: %d",m2);
    } else {
        printf ("\nMultiplicacion Columna 0: %d",m0);
        printf ("\nMultiplicacion Columna 1: %d",m1);
        printf ("\nMultiplicacion Columna 2: %d",m2);
    }
    return 0;
}

void Ingresa_Matriz (int m[3][3], int f, int c) {
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
            printf ("\nIntroduce posicion [%d][%d]: ",f,c);
            scanf ("%d",&amp;m[f][c]);
        }
    }
}

void Utiliza_Matriz (int m[3][3], int f, int c) {
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
            m[f][c]=rand()%50+1;
        }
    }
}

void Visualiza_Matriz (int m[3][3], int f, int c) {
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
            printf ("[%d] ",m[f][c]);
        } printf ("\n");
    }
}
void Rota_Matriz_D (int m[3][3], int f, int c) {
    int tmp[3][3];
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
                if (c == 2) {
                    tmp[f][0]=m[f][c];
                } else {
                    tmp[f][c+1]=m[f][c];
                }
            }
        }
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
            m[f][c]=tmp[f][c];
        }
    }
}

void Rota_Matriz_I (int m[3][3], int f, int c) {
    int tmp[3][3];
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
            if (c == 0) {
                tmp[f][2]=m[f][c];
            } else {
                tmp[f][c-1]=m[f][c];
            }
        }
    }
    
    for (f=0;f&lt;3;++f) {
        for (c=0;c&lt;3;++c) {
            m[f][c]=tmp[f][c];
        }
    }
}

void Multiplica_Matriz (int m[3][3], int f, int c, int cf, int *m0, int *m1, int *m2) {
    // 1 Multiplica filas
    // 0 Multiplica columnas
    int c0[3], c1[3], c2[3];
    
    if (cf == 0) {
        printf ("\nMultiplicando columnas...\n\n");
        for (f=0;f&lt;3;++f) {
            for (c=0;c&lt;3;++c) {
                if (c == 0)
                    c0[f]=m[f][c];
                if (c == 1)
                    c1[f]=m[f][c];
                if (c == 2)
                    c2[f]=m[f][c];
            }
        }
    } else {
        printf ("\nMultiplicando filas...\n\n");
        for (f=0;f&lt;3;++f) {
            for (c=0;c&lt;3;++c) {
                if (f == 0)
                    c0[c]=m[f][c];
                if (f == 1)
                    c1[c]=m[f][c];
                if (f == 2)
                    c2[c]=m[f][c];
            }
        }
    }
    *m0=c0[0]*c0[1]*c0[2];
    *m1=c1[0]*c1[1]*c1[2];
    *m2=c2[0]*c2[1]*c2[2];
}

miércoles, 15 de mayo de 2019

Ejercicio completo en C. Revisión. Matrices y Cálculo

Buen ejemplo de práctica en C.




/*
 
 El ejercicio va a consistir en:
 1. Multiplicar las columnas de una Matriz 3x3
 2. Dado un número cualquiera, deberemos calcular los digitos que tiene y sumarlos
 */

#include <stdio.h>;
#include <stdlib.h>


void Muestra_Matriz (int [3][3], int f, int c);
void Multiplica_Columnas(int m[3][3], int f, int c, int *m0, int *m1, int *m2);
void Calcula_Digitos (int numero, int **digitos, int *longitud);
void Muestra_Digitos (int *digitos, int longitud);
void Calcula_Suma (int *digitos, int longitud, int *suma);

int main () {
    int f=0, c=0, numero;
    int m0, m1, m2;
    int *digitos;
    int longitud;
    int suma;
    
    int m[3][3]={10,20,30,40,50,60,70,80,90};
    
    Muestra_Matriz (m,f,c);
    Multiplica_Columnas (m,f,c, &amp;m0, &amp;m1, &amp;m2);
    
    printf ("El resultado de la columna [1] es: %d \n",m0);
    printf ("El resultado de la columna [2] es: %d \n",m1);
    printf ("El resultado de la columna [3] es: %d \n",m2);

    printf ("Introduce un número :");
    scanf ("%d",&amp;numero);
    
    Calcula_Digitos (numero, &amp;digitos, &amp;longitud);
    printf ("El numero tiene  %d números", longitud);
    Muestra_Digitos(digitos, longitud);
    Calcula_Suma (digitos,longitud,&amp;suma);
    printf ("La suma es: %d",suma);
    return 0;
}

void Calcula_Suma (int *digitos, int longitud, int *suma) {
    int i;
    int tmp=0;
    
    for (i=0; i &lt; longitud; ++i) {
        tmp += digitos[i];
    }
    
    *suma=tmp;
}

void Muestra_Digitos (int *digitos, int longitud) {
    int i;
    printf ("\n");
    for (i=longitud-1; i&gt;=0; --i) {
        printf ("%d",digitos[i]);
    }
    printf ("--\n");
        
}

void Calcula_Digitos (int numero, int **digitos, int *longitud) {
    int n, l;
    int *tmp = NULL;
    
    for (n = numero, l=0; n &gt; 0 ; n = n/10)
    {
        l += 1;
    }
    *longitud = l;

    tmp=calloc(*longitud, sizeof(int));
    
    for (n = numero, l = 0; l &lt; *longitud; n /= 10, ++l) {
        tmp[l]= n % 10;
    }

    *digitos = tmp;
}

void Muestra_Matriz (int m[3][3], int f, int c) {
    for (f=0;f&lt;3;f++) {
        for (c=0;c&lt;3;c++) {
            printf ("[%d]",m[f][c]);
        } printf ("\n");
    }
    
}

void Multiplica_Columnas (int m[3][3], int f, int c, int *m0, int *m1, int *m2) {
    int c0[3];
    int c1[3];
    int c2[3];
    
    for (f=0;f&lt;3;f++) {
        for (c=0;c&lt;3;c++) {
            if (c == 0)
                c0[f]=m[f][c];
            if (c == 1)
                c1[f]=m[f][c];
            if (c == 2)
                c2[f]=m[f][c];
        }
    }
    *m0=c0[0]*c0[1]*c0[2];
    *m1=c1[0]*c1[1]*c1[2];
    *m2=c2[0]*c2[1]*c2[2];
}

viernes, 25 de enero de 2019

Ejercicios resueltos Matrices en C

He recopilado una serie de ejercicios sobre trabajo de matrices en C que espero sean de utilizar, no tenéis más que contactar en caso de dudas.




Ejercicio 1: Escribe un programa que pida cinco enteros al usuario y los almacene en una matriz. Calcula si la suma de los números almacenados es par o impar.



#include <stdio.h>


int main () {
    int m[5];
    int i, suma=0;
    
    for (i=0;i<5;i++) {
        printf ("Introduce numero [%i]: ",i+1);
        scanf ("%i",&m[i]);
    }
    
    for (i=0;i<5;i++) {
        suma+=m[i];
    }
    
    if (suma%2==0) {
        printf ("\nLa suma es PAR: %i",suma);
    } else {
        printf ("\nLa suma es IMPAR: %i",suma);
    }
    return 0;
}


Ejercicio 2: Escribe un programa que pida nueve números enteros y los almacene en una matriz 3x3. Calcula la suma de los números de cada fila y mostrar por pantalla el número de fila con mayor suma.



#include <stdio.h>

int main () {
    int m[3][3];
    int f,c, sumafila=0, nfila=0, mayorfila=0;
    
    for (f=0;f<3;f++) {
        for (c=0;c<3;c++) {
            printf ("Introduce el valor de [%i][%i]",f,c);
            scanf ("%i",&m[f][c]);
        } printf ("\n## Fila [%i] completada\n",f+1);
    }
    
    for (f=0;f<3;f++) {
        sumafila=0;
        nfila=f+1;
        for (c=0;c<3;c++) {
            sumafila+=m[f][c];
            if (sumafila > mayorfila) {
                mayorfila=sumafila;
            }
        }
    }
    
    printf ("\n-----------\n");
    printf ("La fila con suma mayor es: %i con resultado %i",nfila,mayorfila);
    
    return 0;
}


Ejercicio 3: Escribe un programa, que trabajando mediante funciones, presente un menú al usuario, rote la columnas a la derecha y suma filas.




  


#include <stdio.h>  
#define DIMENSION 3  
  
int m[3][3]={10,20,30,40,50,60,70,80,90};  
int n[3][3];  
int a,b,f,c, opcion, suma, resultado;  
  
int IntroduceMatriz (int m[3][3], int f, int c);  
int VisualizaMatriz (int m[3][3], int f, int c);  
int RotarMatrizDrcha (int m[3][3], int f, int c);  
int CambiarFilasColumnas (int m[3][3], int f, int c);  
int SumarFilasColumnas (int m[3][3], int f, int c);  
  
  
//struct ciudadano * CargarBBDDCiudadanos (struct *ciudadano, char *, char *, char *);  
  
  
int main () {  
      
  
    do {  
        printf ("--- MENU ---\n");  
        printf ("1. Introducir Matriz\n");  
        printf ("2. Visualizar Matriz\n");  
        printf ("3. Rotar Matriz Derecha\n");  
        printf ("4. Cambiar Filas/Columnas Matriz\n");  
        printf ("5. Sumar Filas\n");  
        printf ("6. Incremento dinero paso por referencia\n");  
        printf ("7. Incremento dinero paso por valor\n");  
        printf ("9. Salir\n\n");  
        printf ("Seleccione: ");  
        scanf ("%i",&opcion);  
        switch (opcion) {  
            case 1:  
                printf ("\nOpcion 1\n\n");  
                IntroduceMatriz (m, f,c);  
            break;  
            case 2:  
                printf ("\nOpcion 2\n\n");  
                VisualizaMatriz (m,f,c);  
            break;  
            case 3:  
                printf ("\nOpcion 3\n\n");  
                RotarMatrizDrcha (m,f,c);  
            break;  
            case 4:  
                printf ("\nOpcion 4\n\n");  
                CambiarFilasColumnas (m,f,c);  
            break;  
            case 5:  
                printf ("\nOpcion 5\n\n");  
                SumarFilasColumnas (m,f,c);  
            break;  
            case 6:  
                printf ("\nOpcion 6\n\n");  
  
            break;  
            case 7:  
                printf ("\nOpcion 7\n\n");  
  
            default:  
                printf ("\nSeleccione una opcion correcta\n");  
            break;  
                      
        }  
    } while (opcion != 9);  
    return 0;  
}  
  
  
int IntroduceMatriz (int m[3][3], int f, int c) {  
    for (f=0; f<DIMENSION; f++) {  
        for (c=0; c<DIMENSION; c++) {  
            printf ("Introduce coordenada [%i][%i]: ",f,c);  
            scanf ("%i",&m[f][c]);  
        }   
    }  
      
    printf ("\nDone!\n");  
}  
  
int VisualizaMatriz (int m[3][3], int f, int c) {  
    for (f=0; f<DIMENSION; f++) {  
        for (c=0; c<DIMENSION; c++) {  
            printf ("%i  ",m[f][c]);  
        } printf ("\n");  
    }  
      
    printf ("\nDone!\n");  
}  
  
int RotarMatrizDrcha (int m[3][3], int f, int c) {  
    for (f=0; f<DIMENSION; f++) {  
        for (c=0; c<DIMENSION; c++) {  
            if (c == 2) {  
                n[f][0] = m[f][c];  
            } else {  
                n[f][c+1] = m [f][c];  
            }  
        }  
    }  
      
    for (f=0; f<DIMENSION; f++) {  
        for (c=0; c<DIMENSION; c++) {  
            m[f][c] = n[f][c];  
        }  
    }  
    printf ("\nDone!\n");         
}  
  
  
int CambiarFilasColumnas (int m[3][3], int f, int c) {  
    for (f=0; f<DIMENSION; f++) {  
        for (c=0; c<DIMENSION; c++) {  
            n[c][f] = m[f][c];  
        }  
    }  
      
    for (f=0; f<DIMENSION; f++) {  
        for (c=0; c<DIMENSION; c++) {  
            m[f][c] = n[f][c];  
        }  
    }  
    printf ("\nDone!\n");         
}  
  
  
int SumarFilasColumnas (int m[3][3], int f, int c) {  
      
    for (f=0; f<DIMENSION; f++) {  
        suma=0;  
        for (c=0; c<DIMENSION; c++) {  
            suma+=m[f][c];  
            //printf ("Debug: %i\n",suma);  
            if (c == 2) {  
                printf ("\nLa Fila [%i] suma: %i\n",f,suma);  
            }  
        }  
    }  
      
    printf ("\nDone!\n");         
}