Saber numeros primeros en una cadena desordenada pero a voluntad del usuario ?

[luis456]

Código [Seleccionar] Expandir

En este codigo que saca los numeros primos ,se podria hacerlo pero que el usuario ponga la cantidad de numeros y sin importar el orden de los mismos ?

que se ponga ejemplo 1 3 5 48 99 75 65 88  77  a lo bestia por decir algo y que el programa diga cuales son los primos y los muestre ahora si en orden ?


[code#include<iostream>
using namespace std;

int main()
{
  int n=0,c=0,c2=0,res=0,nc=0;
  cout<<"Introduce el limite de numeros: "; cin>>n;
  for(c=1;c<=n;c++)
  {
    for(c2=1;c2<=c;c2++)
    {
      res=c%c2;
      if(res==0)
      {
        nc=nc+1;
      }
    }
    if(nc==2)
    {
      cout<<" "<<c;
    }
    nc=0;
  }
  system("pause");//Damos una pausa antes de finalizar el programa
return 0;
}]


Luis

[avesudra]

Si pero habría que parar de introducir de alguna manera , como pedirle al usuario que el último número sea un 0, o cuantos números piensa introducir que no es lo más común, en este programa que acabo de hacer he utilizado el algoritmo de ordenación Quicksort , y las funciones las he sacado de aquí:

http://blog.e-urrea.com/noticias/2011/03/23/metodo-de-ordenacion-burbuja-y-quicksort-en-c/

Tu código es complicado de entender porque no utilizas nombres de variables descriptivos :S .El código que tienes ahí abajo va introduciendo numeros a la variable arrayDeNumeros hasta que se introduce un 0, después ordena el array y mira si cada numero es primo. Es sencillo. Te dejo el que he hecho así rápido para que te hagas una idea:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <cmath>

using namespace std;

bool esPrimo(unsigned int num);
void Quicksort(int *unarray, int izq, int der);
int pivot(int *unarray, int izq, int der);

int main(int argc, char *argv[])
{
    int *arrayDeNumeros= (int*) calloc(1000,sizeof(int*));
    int lenArray = 0;
    cout << "Ingrese una cadena de numeros terminada en 0:" << endl;
    cin>>arrayDeNumeros[0];
    for(register int i = 1; arrayDeNumeros[i-1]!=0 ; ++i)
    {
        cin>>arrayDeNumeros[i];
        lenArray = i;
    }
    /** El algoritmo que viene a continuación lo que hace
     *  es ordenar  el array  arrayDeNumeros de  menor  a
     *  mayor,sinceramente,no sé como funciona solo que he
     *  leído que era rápido y lo he buscado.
     */

    Quicksort(arrayDeNumeros,0,lenArray);
    /**
     *  El siguiente bucle mira si los enteros que ya están
     *  ordenados son primos o no.
     */
    for(register int i = 1; arrayDeNumeros[i]!=0; ++i)
    {
        if(esPrimo(arrayDeNumeros[i]))
            cout<<"El numero "<<arrayDeNumeros[i]<<" es primo."<<endl;
        else
            cout<<"El numero "<<arrayDeNumeros[i]<<" no es primo."<<endl;
    }
    return 0;
}

void Quicksort(int *unarray, int izq, int der)
{
    int pivote;
    if(izq < der)
    {
        pivote=pivot(unarray, izq, der);
        Quicksort(unarray, izq, pivote-1);
        Quicksort(unarray, pivote+1, der);
    }
}
int pivot(int *unarray, int izq, int der)
{
    int i;
    int pivote, valor_pivote;
    int aux;

    pivote = izq;
    valor_pivote = unarray[pivote];
    for (i=izq+1; i<=der; i++)
    {
        if (unarray[i] < valor_pivote)
        {
            pivote++;
            aux=unarray[i];
            unarray[i]=unarray[pivote];
            unarray[pivote]=aux;

        }
    }
    aux=unarray[izq];
    unarray[izq]=unarray[pivote];
    unarray[pivote]=aux;
    return pivote;
}
bool esPrimo(unsigned int num)
{
    if(num>2 && (num%2==0))/* Si el número es mayor que 2 y es divisible por el entonces no es primo*/
        return false;
    /**
     * Para comprobar si un número es primo se suele
     * utilizar el siguiente algoritmo, que consiste
     * en llegar hasta la raiz cuadrada del número de
     * dos en dos y empezando en 3, ya que un número
     * que no es par en la vida puede ser dividido por
     * un par.
     */
    unsigned int numSquare = (unsigned int)sqrt(num);
    for(register unsigned int i =3; i<=numSquare ; i+=2)
    {
        if(num%i==0)
        {
            return false;
        }
    }
    return true;
}

[BlackZeroX]

En lugar de reinventar la rueda ( Quicksort ) usa qsort(), aun que en el código no es necesario usar este algoritmo... posiblemente solo hacer un "registro" o cache de los números generados para aumentar la velocidad, pero para números tan pequeños es mejor así.

Dulces Lunas!¡.

[luis456]

Si pero habría que parar de introducir de alguna manera , como pedirle al usuario que el último número sea un 0, o cuantos números piensa introducir que no es lo más común, en este programa que acabo de hacer he utilizado el algoritmo de ordenación Quicksort , y las funciones las he sacado de aquí:

http://blog.e-urrea.com/noticias/2011/03/23/metodo-de-ordenacion-burbuja-y-quicksort-en-c/

Tu código es complicado de entender porque no utilizas nombres de variables descriptivos :S .El código que tienes ahí abajo va introduciendo numeros a la variable arrayDeNumeros hasta que se introduce un 0, después ordena el array y mira si cada numero es primo. Es sencillo. Te dejo el que he hecho así rápido para que te hagas una idea:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <cmath>

using namespace std;

bool esPrimo(unsigned int num);
void Quicksort(int *unarray, int izq, int der);
int pivot(int *unarray, int izq, int der);

int main(int argc, char *argv[])
{
    int *arrayDeNumeros= (int*) calloc(1000,sizeof(int*));
    int lenArray = 0;
    cout << "Ingrese una cadena de numeros terminada en 0:" << endl;
    cin>>arrayDeNumeros[0];
    for(register int i = 1; arrayDeNumeros[i-1]!=0 ; ++i)
    {
        cin>>arrayDeNumeros[i];
        lenArray = i;
    }
    /** El algoritmo que viene a continuación lo que hace
     *  es ordenar  el array  arrayDeNumeros de  menor  a
     *  mayor,sinceramente,no sé como funciona solo que he
     *  leído que era rápido y lo he buscado.
     */

    Quicksort(arrayDeNumeros,0,lenArray);
    /**
     *  El siguiente bucle mira si los enteros que ya están
     *  ordenados son primos o no.
     */
    for(register int i = 1; arrayDeNumeros[i]!=0; ++i)
    {
        if(esPrimo(arrayDeNumeros[i]))
            cout<<"El numero "<<arrayDeNumeros[i]<<" es primo."<<endl;
        else
            cout<<"El numero "<<arrayDeNumeros[i]<<" no es primo."<<endl;
    }
    return 0;
}

void Quicksort(int *unarray, int izq, int der)
{
    int pivote;
    if(izq < der)
    {
        pivote=pivot(unarray, izq, der);
        Quicksort(unarray, izq, pivote-1);
        Quicksort(unarray, pivote+1, der);
    }
}
int pivot(int *unarray, int izq, int der)
{
    int i;
    int pivote, valor_pivote;
    int aux;

    pivote = izq;
    valor_pivote = unarray[pivote];
    for (i=izq+1; i<=der; i++)
    {
        if (unarray[i] < valor_pivote)
        {
            pivote++;
            aux=unarray[i];
            unarray[i]=unarray[pivote];
            unarray[pivote]=aux;

        }
    }
    aux=unarray[izq];
    unarray[izq]=unarray[pivote];
    unarray[pivote]=aux;
    return pivote;
}
bool esPrimo(unsigned int num)
{
    if(num>2 && (num%2==0))/* Si el número es mayor que 2 y es divisible por el entonces no es primo*/
        return false;
    /**
     * Para comprobar si un número es primo se suele
     * utilizar el siguiente algoritmo, que consiste
     * en llegar hasta la raiz cuadrada del número de
     * dos en dos y empezando en 3, ya que un número
     * que no es par en la vida puede ser dividido por
     * un par.
     */
    unsigned int numSquare = (unsigned int)sqrt(num);
    for(register unsigned int i =3; i<=numSquare ; i+=2)
    {
        if(num%i==0)
        {
            return false;
        }
    }
    return true;
}

Gracias por el codigo y la respuesta pero lo que nesecito es que me muestre cuales son los numeros primos ordenados y este lo que me dice si son o nos son primos

Luis

[avesudra]

En lugar de reinventar la rueda ( Quicksort ) usa qsort(), aun que en el código no es necesario usar este algoritmo... posiblemente solo hacer un "registro" o cache de los números generados para aumentar la velocidad, pero para números tan pequeños es mejor así.

Dulces Lunas!¡.

Gracias BlackZeroX (Astaroth) no sabía de la existencia de esa función. luis456 en cuanto a lo que dices solo habría que cambiar esto:

Código (cpp) [Seleccionar] Expandir

for(register int i = 1; arrayDeNumeros[i]!=0; ++i)
    {
        if(esPrimo(arrayDeNumeros[i]))
            cout<<arrayDeNumeros[i]<<endl;
    }

[luis456]

Gracias a los dos por sus respuestas ahora cambie lo que me has dicho pero no logro parar el programa para ver el resultado ? estoy poniendo esto

pero no va
luis

Código [Seleccionar] Expandir

system("pause");//Damos una pausa antes de finalizar el programa

[avesudra]

Es mejor que utilices:

Código (cpp) [Seleccionar] Expandir


cin.sync();// Para ignorar los carácteres no leidos...(limpiar el buffer)
cout << endl<<endl<<"Presione una tecla para continuar . . .";
cin.get();// Utiliza esto que es portable.
Lo siento se me olvidó ponerlo en el código :/

[luis456]

Es mejor que utilices:

Código (cpp) [Seleccionar] Expandir


cin.sync();// Para ignorar los carácteres no leidos...(limpiar el buffer)
cout << endl<<endl<<"Presione una tecla para continuar . . .";
cin.get();// Utiliza esto que es portable.
Lo siento se me olvidó ponerlo en el código :/

Ya me volvi un ocho jejej se supone que debo eliminar y poner eso donde ? al principio o al final ya que lo he puesto y solo me sale lo de presionar la tecla

luis

[avesudra]

Así lo tengo yo y funciona(he cambiado las funciones por la que decía Blackzero):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <cmath>

using namespace std;

bool esPrimo(unsigned int num);
int int_cmp(const void *a, const void *b);//Función para pasarla a qsort


int main(int argc, char *argv[])
{
    int *arrayDeNumeros= (int*) calloc(1000,sizeof(int*));
    int lenArray = 0;
    cout << "Ingrese una cadena de numeros terminada en 0:" << endl;
    cin >> arrayDeNumeros[0];
    for(register int i = 1; arrayDeNumeros[i-1]!=0 ; ++i)
    {
        cin>>arrayDeNumeros[i];
        lenArray = i;
    }
    /** El algoritmo que viene a continuación lo que hace
     *  es ordenar  el array  arrayDeNumeros de  menor  a
     *  mayor,sinceramente,no sé como funciona solo que he
     *  leído que era rápido y lo he buscado.
     */

    qsort(arrayDeNumeros,lenArray,4,int_cmp);
    /**
     *  El siguiente bucle mira si los enteros que ya están
     *  ordenados son primos o no.
     */
    cout << "Los primos son: ";
    for(register int i = 1; arrayDeNumeros[i]!=0; ++i)
    {
        if(esPrimo(arrayDeNumeros[i]))
            cout<<arrayDeNumeros[i]<<" ";
    }
    cin.sync();// Para ignorar los carácteres no leidos...(limpiar el buffer)
    cout << endl<<endl<<"Presione una tecla para continuar . . .";
    cin.get();// Utiliza esto que es portable.
    return 0;
}
bool esPrimo(unsigned int num)
{
    if(num>2 && (num%2==0))/* Si el número es mayor que 2 y es divisible por el entonces no es primo*/
        return false;
    /**
     * Para comprobar si un número es primo se suele
     * utilizar el siguiente algoritmo, que consiste
     * en llegar hasta la raiz cuadrada del número de
     * dos en dos y empezando en 3, ya que un número
     * que no es par en la vida puede ser dividido por
     * un par.
     */
    unsigned int numSquare = (unsigned int)sqrt(num);
    for(register unsigned int i =3; i<=numSquare ; i+=2)
    {
        if(num%i==0)
        {
            return false;
        }
    }
    return true;
}
int int_cmp(const void *a, const void *b)
{
    const int *ia = (const int *)a; // casting pointer types
    const int *ib = (const int *)b;
    return *ia  - *ib;
    /* integer comparison: returns negative if b > a
    and positive if a > b */
}

[luis456]

Sera que uso Dev ya que el programa no se detiene a mostrarme los numeros compila bien y todo,pero no me muestra nada de lo rapido que se sale

luis

Así lo tengo yo y funciona(he cambiado las funciones por la que decía Blackzero):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <cmath>

using namespace std;

bool esPrimo(unsigned int num);
int int_cmp(const void *a, const void *b);//Función para pasarla a qsort


int main(int argc, char *argv[])
{
    int *arrayDeNumeros= (int*) calloc(1000,sizeof(int*));
    int lenArray = 0;
    cout << "Ingrese una cadena de numeros terminada en 0:" << endl;
    cin >> arrayDeNumeros[0];
    for(register int i = 1; arrayDeNumeros[i-1]!=0 ; ++i)
    {
        cin>>arrayDeNumeros[i];
        lenArray = i;
    }
    /** El algoritmo que viene a continuación lo que hace
     *  es ordenar  el array  arrayDeNumeros de  menor  a
     *  mayor,sinceramente,no sé como funciona solo que he
     *  leído que era rápido y lo he buscado.
     */

    qsort(arrayDeNumeros,lenArray,4,int_cmp);
    /**
     *  El siguiente bucle mira si los enteros que ya están
     *  ordenados son primos o no.
     */
    cout << "Los primos son: ";
    for(register int i = 1; arrayDeNumeros[i]!=0; ++i)
    {
        if(esPrimo(arrayDeNumeros[i]))
            cout<<arrayDeNumeros[i]<<" ";
    }
    cin.sync();// Para ignorar los carácteres no leidos...(limpiar el buffer)
    cout << endl<<endl<<"Presione una tecla para continuar . . .";
    cin.get();// Utiliza esto que es portable.
    return 0;
}
bool esPrimo(unsigned int num)
{
    if(num>2 && (num%2==0))/* Si el número es mayor que 2 y es divisible por el entonces no es primo*/
        return false;
    /**
     * Para comprobar si un número es primo se suele
     * utilizar el siguiente algoritmo, que consiste
     * en llegar hasta la raiz cuadrada del número de
     * dos en dos y empezando en 3, ya que un número
     * que no es par en la vida puede ser dividido por
     * un par.
     */
    unsigned int numSquare = (unsigned int)sqrt(num);
    for(register unsigned int i =3; i<=numSquare ; i+=2)
    {
        if(num%i==0)
        {
            return false;
        }
    }
    return true;
}
int int_cmp(const void *a, const void *b)
{
    const int *ia = (const int *)a; // casting pointer types
    const int *ib = (const int *)b;
    return *ia  - *ib;
    /* integer comparison: returns negative if b > a
    and positive if a > b */
}