Como se hace esto; un programa que muestre los números primos del 1 al 100.Lo hago mal porque me salen todos los numeros del 1 al 100 y no creo que todos sean numeros primos xDDD Ayuda plz
Pon por lo menos tu codigo, no querras que te lo hagamos entero...
P.D: Es muy sencillo, se puede resolver con un par de bucles anidados.
Yo de momento no he hecho nada con C++, pero vamos, no creo que sea muy dificil hacer un bucle del 1 al 100, evaluar para cada numero si solo se puede dividir por si mismo y si se cumple añadir ese numero a una cadena...
¿Y qué es lo que no sabes hacer? ¿Programar en C++, o un algoritmo para mostrar los números primos?
Si no especificas algo más, está difícil ayudarte.
Los numeros primos son los que se dividen por si y por 1 no no? No puede ser divisible por otro numero que no sea el mismo y el 1, no?
Es que no se lo que tengo que poner en el for que necesito evidentemente xD
No se que estudiarás pero no saber que es un número primo... lo llevas difícil en el tema de la programación pero bueno.
Lo que tienes que hacer es recorrer la cadena del 1 al 100 comprobando que se puede dividir únicamente por sí mismo (cualquier número es divisible por 1). Yo empezaría por el 2 y pondría el 1 sin comprobarlo, aunque si te piden que recorras toda la cadena pues empiezas desde el 1.
Unas pistas: Necesitas dos bucles for, uno para cada número de la cadena y otro que compruebe si es divisible por todos los números desde el 2 hasta la mitad de ese número.
Un ejemplo:
el 80: Tendrías que hacer un bucle desde el 2 hasta el 40.
P.D.: Se puede comprobar del 1 hasta el mismo número pero ese algoritmo es totalmente ineficiente ya que es imposible que un número sea divisible por un número superior a su mitad y que no sea divisible por otro número inferior a su mitad.
Un saludo
Necesitas hacer una función que compruebe si un número es primo o no. Haces un for que vaya del 1 al 100, y que llame a esa función, algo así.
Funcion numeros primos (numero)
---aqui compruebas si es primo o no---
si es primo
devolver true
si no
devolver false
Fin función
y el bucle for ya sería muy simple
para i = 1, mientras i menor o igual que 100, i++
si ( numeros primos (i))
imprimir i
Fin si
Fin para
http://foro.elhacker.net/index.php/topic,101680.msg473570.html
google es tu amigo, en especial el de todos los estudiantes ..XD ni lo he mirado pero parece que le funciona
Te digo como lo haria yo:
Crearia un array de booleanos con 101 posiciones, osea para que fueran de la posicion 0 a la 100. Iniciaria todas las posiciones a VERDADERO. Y luego haria esto:
for (i=2;i<101;i++){
for (j=i+1;j<101;j++){
if (j % i == 0) array[j] = FALSO;}
}
Luego solo tienes que recorre el array desde 2 hasta 100 y las que sean aun VERDADERO son numeros primos.
Un par de mejoras:
1) En for (j=i+1;j<101;j++) poner mejor:
for (j=i*2;j<101;j++) ya que como dice Pelotaso para que pueda ser divisible al menos tiene que ser el doble y cuanto mas grande sea i mas casos se saltan.
2) Hacer el programa en funcion de una constante para que solo cambiandola se cambie el numero de numeros que encuentra:
DEFINE BUSCA 100
Crea un array de booleanos de tamaño BUSCA + 1, osea para que fueran de la posicion 0 a la BUSCA. Iniciaria todas las posiciones a VERDADERO. Y luego haria esto:
for(i=2;i < BUSCA + 1;i++){
for(j=i*2;j < BUSCA + 1;j++){
if (j % i == 0) array[j] = FALSO;
}
}
Luego solo tienes que recorre el array desde la posicion 2 hasta BUSCA y las que sean aun VERDADERO son numeros primos.
Ya tienes un programa que te busca 100 o los que pongas en la constante y realmente corto y sencillo 
Aquí tienes como lo haría yo. Yo he tomado el número 1 como primo aunque por convenio no se suele tomar como primo, en el caso de que tu profesor no quiera que lo pongas sólo tienes que borrarlo del cout:
#include iostream //esto iría entre < > pero no me deja ponerlos.
using namespace std;
int main()
{
bool encontrado;
cout << "1" << endl << "2" << endl;
for(int i=3;i<=100;i++)
{
encontrado = false;
for(int j=2;j<=i/2;j++)
{
if ((i%j)==0)
{
encontrado = true;
j=i/2;
}
}
if(encontrado == false)
cout << i << endl;
}
return 0;}
P.D.: Ya se que no es conveniente usar el namespace estandar pero viendo lo que hace él no creo que le pongan pegas.
#14 Creo que el mio es mas sencillo y eficiente, ademas conservas los primos y ahora me he dado cuenta de otra cosa, si se cambia:
for(j=i*2;j < BUSCA + 1;j++) que sugerias para ahorrar casos por:
for(j=i*i;j < BUSCA + 1;j++) sigue siendo valido y aun se ahorran muchos mas casos.
Pq? pq mi algoritmo va eliminando primero todos los multiplos de 2, luego los de 3, luego los de 4...
Imaginate que vamos por el 5, segun tu habria que empezar a buscar por el 10 (52), pero tal como yo lo hago no hace falta ya que el 10 es multiplo de 2 y ya ha sido eliminado antes, el siguiente multiplo de 5 es el 15 que es multiplo de 3 y ya ha sido eliminado antes, el siguiente es el 20 que es multiplo de 4 y tb ha sido eliminado, el primero en el que hay que buscar es en el 25. Para el 6 seria el 36... En mi caso se pasa del i2 al i*i.
#include < iostream>
using namespace std;
bool primo(int n)
{
for (int i = 2; i < n; i++)
if ((n % i) == 0)
return false;
return true;
}
int main()
{
for (int n = 1; n <= 100; n++)
if (primo(n))
cout << n << endl;
}
#15 Yo he sugerido todo lo contrario a lo que tú dices. Tú dices de empezar por el doble del número a comprobar, yo lo que digo es comprobar hasta la mitad del número. Es decir, si queremos comprobar el 11 lo que haríamos sería probar hasta el 5 (ya que al ser entero no existe el 5.5), si ninguno lo divide entonces es primo. Lo que tú dices no acabo de entenderlo y no me apetece implementarlo pero vamos no tiene pinta de que sea mucho más eficiente.
Lo de guner es = que lo de Pelotaso aunque de forma mas agradable de leer quizá pero un poco menos eficiente ya que en la funcion "primo" tiene puesto:
for (int i = 2; i < n; i++) cuando lo mejor en ese caso seria:
for (int i = 2; i < n/2; i++)
#19, muy cierto, ni lo había pensado, y ya de paso si quitamos todas las comprobaciones con números pares, nos ahorramos unas cuantas iteraciones ^.
no he leido las respuestas pero yo haria esto, no me he parado a verificar el algoritmo xD (en pseudocodigo puesto que no se c++)
inicio
n:entero;
i:entero;
j:entero;
primo:logico=verdadero;
desde i=1 hasta 100
......n=i;
......desde j=n/2 hasta 1
............si (n)%j == 0 entonces
..................primo=falso;
............fin_si
......fin_desde
......si primo==verdadero entonces
............escribirEntero(n);
......si_no
............primo==verdadero;
......fin_si
fin_desde
fin
(probablemente lo tenga mal :S)
y si en el for en ved de llegar hasta la mitad del numero, llegas hasta su raiz cuadrada, te ahorras unas cuantas mas 
¿No os dáis cuenta de que esta pregunta la ha hecho una novata y estáis con que si el algoritmo es más eficiente, que si no se qué?
Ya de paso, se lo ponemos en ensamblador xD
No os lo toméis a mal, pero algunos en lugar de intentar ayudarla, parece que intentan demostrar cuanto saben.
No os lo toméis a mal, pero algunos en lugar de intentar ayudarla, parece que intentan demostrar cuanto saben.
Pim Pam Pum xD
Salu2
PD: para acabar de dar la razón a cabrón (estos moderatas sin avatar despistan muuuuucho) os voy a poner la demostración de por qué vale con probar hasta la raíz de n. Con todo mi cariño:
HAY UN TEOREMA que dice así:
Si n es un entero compuesto, entonces n tiene un divisor primo menor o igual que raíz(n)
Demostración de dicho teorema:
1) Si n es compuesto (lo contrario a primo) debe tener un factor a, 1<a<n Por tanto, n=a*b (No te preocupes por saber cuanto valen a y b, eso NO importa).
2) Bien, tanto a como b son enteros positivos mayores que uno. Por lo tanto o bien a<=raiz(n) o bien b<=raiz(n), ya que de no ser así ab>n (Y eso no tiene sentido ya que ab dijimos que era n).
3) Del paso 2) se deduce que n debe tener un divisor positivo MENOR o IGUAL que raiz(n) (El a o el b que dijimos antes). Y dicho divisor o bien es primo o bien tiene un divisor primo.
Ejemplo:
15 = a*b
a=3 b=5 (a es primo y menor que raíz(15))
===================================
28 = a*b
a=4 y b=7
a= 2*2 b=7 (El a no es primo, pero sí tiene un divisor primo que es el 2)
Si os fijáis bien el teorema dice que n tiene UN divisor primo menor o igual que raíz(n) En ningún caso dice que todos los divisores primos de n sean menores que su raíz. ¿Ein? ¿Entonces en qué quedamos?:
Pos que TODO número compuesto (no primo) tendrá por huevos AL MENOS UN divisor primo menor o igual que la raíz. Por eso, una vez pasada la raíz, si no hemos encontrado divisores es que el número es PRIMO.
la solución de leer números hasta la raíz parece ser la mejor. De echo es la que propusierón como posible solución en un ejercicio (algo parecido a éste) de examen de programación de universidad.
Salu2
PDT:
Demonia te aconsejo que veas algún libro de matemáticas discretas. Hay muchos problemas de este tipo que se piden para aprender programación y en algún libro de M.D. los encontraras resueltos. Tambien te aconsejo que si no sabes hacer algún programa al menos intentalo hacer en un folio, haciendo su traza. No aprenderas mucho si al más mínimo problema vas a un foro para que te hagan el ejercicio sin haberlo pensado mucho.
Se nota que no se ha molestado lo mas minimo, porlomenos podia haber buscao en google la definicion de numeros primos :/
Pero como toy aprendiendo C++ io tmb pos me he propuesto hacerlo.
#include < iostream.h>
int main() {
const int HASTA=100;
int primos[HASTA], i=1, j, total=0;
bool loes;
for (i=1; i<HASTA; ++i) {
loes=true;
for (j=1; j<total; ++j) {
if (i%primos[j] == 0) {
loes=false;
j=i;
}
}
if (loes) {
primos[total++]=i;
cout << i << " ";
}
}
cout << "\ntotal econtrados " << total;
}
#19 si al for le pones "i < n/2" al listado se añade el 4 y creo que no es primo, si que es verdad que ahoras proceso pero estaria mal el ejercicio.
