Mensajes

¿cómo a traves de una función podemos devolver un array de estructuras?
Es decir se supone que yo introduciré tanto la edad para p[0] y p[1] y lo mismo con el nombre... pero como se hace para devolver con la función todo esto y pasarlo a otro array

Puedes hacer algo asi:

Código (cpp) [Seleccionar] Expandir

typedef struct
{
    int edad;
    string nombre;
} persona;

persona* registrarPersonas( persona* datos, int n);

int main(void)
{
    persona datos[2];
    persona* info;

    info = registrarPersonas(datos, 2);

    for(int i = 0; i < 2; i++)
        cout << "Nombre: " << info[i].nombre << "\nEdad: "   << info[i].edad << endl;

    return 0;
}
persona* registrarPersonas( persona* datos, int n)
{
    for(int i = 0; i < n; i++)
    {
        cout << "Nombre: ";
        getline(cin, datos[i].nombre );

        cout << "Edad: ";
        cin >> datos[i].edad;
        cin.ignore();
    }
    return datos;
}


Un Saludo

si tengo algunos fallos decírmelo también, gracias por las molestias.  

Esto mas bien seria una pequeña modificación para obtener mayor eficiencia y rapidez :

Código (cpp) [Seleccionar] Expandir

for(B = 2; B <= E; B++)
{
   C = 2;
   while (C * C <= B  && B % C != 0) C++;
   if (C * C  > B)
       printf("%6d\n", B);
}

Y respecto a lo que intentas hacer podrías especificar exactamente como quieres imprimirlos

Saludos

[NOB2014]

Le encontré 2 cosas que se deben cambiar.
Si el operando más a la izquierda tiene menos cifras que el de la derecha, el resultado es erróneo.
456 x 1234
La otra, si el operando más a la derecha tiene más de una cifra, el resultado también falla.-   
456 x 12

Claro yo solo seguí la lógica de tu código asumiendo que el multiplicador seria no mas de un dígito para encarar operaciones del tipo que expones se tendría que hacer importantes modificaciones al código; quedaría un poco mas extenso y complejo

Un Saludo NOB2014

[j]

pero lo que me trae en este momento y sin ello no puedo seguir es que sintaxis debo utilizar para copiar resultadoInt en resultadoChar[j] y si me pudieran decir si estoy bien rumbeado.-

Inicializar j a 2 para ir almacenando el resultado en la ultima posición del array  e ir decrementandolo sucesivamente, te dejo el código con todas las correcciones en especial la parte de acarreo que no tomaba algunos casos :

Código (cpp) [Seleccionar] Expandir

int main(void)
{
    char a[] = "914", b[] = "3", mult[4];
    int i, j, result = 0, resto = 0, operUno = 0, operDos = 0;

    for(i = j = 2; i >= 0; i--, j--)
    {
        operUno = a[i] - '0', operDos = b[0] - '0';
        result = operUno * operDos + resto;
        if (result >= 10)
        {
            resto = result / 10;
            result -= resto * 10;
        }
        else
            resto = 0;
        mult[j] = result;
    }
    if (resto)
    {
        for( i = 3; i > 0; i--)
            mult[i] = mult[i - 1];
        mult[0] = resto;
    }
    for(i = 0; i < 4 ; i++)
        printf("%d", mult[i]);

    return 0;
}


Un saludo

Estoy de acuerdo y con esa modificación los primos están correctos pero los perfectos me parece que no.-

El problema con el código del compañero es que de igual manera procesa los primos no validos (23, 29) y también mencionar el desbordamiento de enteros producido, he aquí un ejemplo que calcula los ocho números perfectos :

Código (cpp) [Seleccionar] Expandir

#include <math.h>
#include <stdio.h>
#include <limits.h>

typedef enum { FALSE = 0, TRUE = 1 } BOOL;

BOOL is_prime( int p )
{
    if( p == 2 ) return TRUE;
    else if( p <= 1 || p % 2 == 0 ) return FALSE;
    else
    {
        BOOL prime = TRUE;
        const int to = sqrt(p);
        int i;
        for(i = 3; i <= to; i+=2)
            if (!(prime = p % i))
                break;
        return prime;
    }
}

BOOL is_mersenne_prime( int p )
{
    if( p == 2 )
        return TRUE;
    else
    {
        long long unsigned m_p = ( 1U << p ) - 1;
        long long unsigned s = 4;
        int i;
        for (i = 3; i <= p; i++)
        {
            s = (s * s - 2) % m_p;
        }
        return s == 0;
    }
}

int main(int argc, char **argv)
{
    const int upb = log2l(ULLONG_MAX)/2;
    int p;

    for( p = 2; p <= upb; p++ )
    {
        if( is_prime(p) && is_mersenne_prime(p) )
            printf(" %llu\n", (long long unsigned)(1U << (p - 1)) * ((1U << p) - 1));
    }
    printf("\n");

    return 0;
}


Puedes comprobarlo aquí :

http://www.vaxasoftware.com/doc_edu/mat/numperfe_esp.pdf

Un saludo

[Blaster]

Blaster seguro que solo con los primos de mersenne?

entonces la secuencia da
no están el 2, 5, 13, 17,23... sin embargo son tomados en la secuencia de los perfectos... así que creo que la teoría es incorrecta

Con el algoritmo que propuse por supuesto se obtienen esa secuencia de primos menos el 23 el cual no forma parte de la secuencia de números perfectos en ves debes incluir el tres. Estoy utilizando la prueba de Lucas-Lehmer :

http://es.wikipedia.org/wiki/Test_de_Lucas-Lehmer

Para descartar todos los primos no valido, por otra parte en la función es_primo en tu código tienes un pequeño error la condición del for debe quedar así

Código (cpp) [Seleccionar] Expandir

prueba*prueba <= numero

Debido a esto validaba el nueve como un primo

Para generar los cinco números perfectos conocidos (6, 28, 496, 8128, 33550336) con la formula de  Euclides es necesario trabajar con los primos de mersenne (2, 3, 5, 7, 13)  aquí un ejemplo :

Código (cpp) [Seleccionar] Expandir

#include <math.h>
#include <stdio.h>
#include <limits.h>

typedef enum { FALSE = 0, TRUE = 1 } BOOL;

BOOL is_prime( int p )
{
    if( p == 2 ) return TRUE;
    else if( p <= 1 || p % 2 == 0 ) return FALSE;
    else
    {
        BOOL prime = TRUE;
        const int to = sqrt(p);
        int i;
        for(i = 3; i <= to; i+=2)
            if (!(prime = p % i))break;
        return prime;
    }
}

BOOL is_mersenne_prime( int p )
{
    if( p == 2 )
        return TRUE;
    else
    {
        unsigned m_p = ( 1U << p ) - 1;
        unsigned s = 4;
        int i;
        for (i = 3; i <= p; i++)
            s = (s * s - 2) % m_p;
        return s == 0;
    }
}

int main(void)
{
    int p;

    for( p = 2; p <= 13; p += 1 )
        if( is_prime(p) && is_mersenne_prime(p) )
           numero_perfecto(p);
           /*printf("%d ", p);*/
    printf("\n");

    return 0;
}


Un Saludo

La consulta es, ¿sabe alguien otra manera de hacerlo?, mi computadora si bien es un poco vieja (2gb de ram) me parecería que tendría que mostrarlo al instante, pero no es así.-

Aquí tienes un código bastante interesante, que a mi parecer es bastante rápido :

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

char bits[65536];

typedef unsigned long ulong;
ulong primes[7000], n_primes;

typedef struct
{
    ulong p, e;
} prime_factor;

void sieve(void)
{
    int i, j;
    memset(bits, 1, 65536);
    bits[0] = bits[1] = 0;
    for (i = 0; i < 256; i++)
        if (bits[i])
            for (j = i * i; j < 65536; j += i)
                bits[j] = 0;
    for (i = j = 0; i < 65536; i++)
        if (bits[i]) primes[j++] = i;

    n_primes = j;
}

int get_prime_factors(ulong n, prime_factor *lst)
{
    ulong i, e, p;
    int len = 0;

    for (i = 0; i < n_primes; i++)
    {
        p = primes[i];
        if (p * p > n) break;
        for (e = 0; !(n % p); n /= p, e++);
        if (e)
        {
            lst[len].p = p;
            lst[len++].e = e;
        }
    }
    return n == 1 ? len : (lst[len].p = n, lst[len].e = 1, ++len);
}

int ulong_cmp(const void *a, const void *b)
{
    return *(const ulong*)a < *(const ulong*)b ? -1 : *(const ulong*)a > *(const ulong*)b;
}

int get_factors(ulong n, ulong *lst)
{
    int n_f, len, len2, i, j, k, p;
    prime_factor f[100];

    n_f = get_prime_factors(n, f);

    len2 = len = lst[0] = 1;
    for (i = 0; i < n_f; i++, len2 = len)
        for (j = 0, p = f[i].p; j < f[i].e; j++, p *= f[i].p)
            for (k = 0; k < len2; k++)
                lst[len++] = lst[k] * p;

    qsort(lst, len, sizeof(ulong), ulong_cmp);
    return len;
}

int main(void)
{
    int j;
    ulong fac[10000], n, sum;

    sieve();

    for (n = 2; n < 33550337; n++)
    {
        j = get_factors(n, fac) - 1;
        for (sum = 0; j && sum <= n; sum += fac[--j]);
           if (sum == n)
              printf("%lu\n", n);
    }
    return 0;
}


Fuente : http://rosettacode.org/wiki/Factors_of_an_integer#Prime_factoring

Solo le hice una pequeña modificación en el main para adaptarlo a tu propósito

Un Saludo

[qsort]

Haciendo uso de qsort podríamos ir ordenando sucesivamente los elementos generados, mas o menos así :

Código (cpp) [Seleccionar] Expandir


int comparar(const void * x, const void * y)
{
    return ( *(int*)x - *(int*)y );
}

void generar(void)
{
    int guardar[6], numero = 0;
    int i, hora = time(NULL);

    srand(hora);

    for (i = 0; i <= 6; i++)
    {
        numero = rand() % 46;

        guardar[i] = numero;

        qsort(guardar, i, sizeof(int), comparar);
    }
}


Un Saludo

[abs]

Pero por mas que intento no puedo generar la mitad derecha, alguien me podría ayudar a darme una idea o alguna pista de que tengo que hacer para generar la mitad derecha?

Puedes generar la figura completa de la siguiente manera :

Código (cpp) [Seleccionar] Expandir

int i = -5, j = 0;

while(i <= 5)
{
     j = -5;
     while( j <= 5)
    {
         printf("%c", abs(i) <= abs(j) ? '*' : ' ');
         j++;
    }
     putchar('\n');
     i++;
}

Usando la función abs con la cual vamos dibujando las dos figuras juntas al mismo tiempo..

Un Saludo