Arquivo Discussoes de Programacao e Tecnologia public class SemTitulo {
public static void main(String[] arg) {
String linhastr = "";
int a [] = new int[15000];
for(int arranjo = 0; arranjo < a.length; arranjo+=10){
a[arranjo] = a.length - arranjo;
System.out.println(a[arranjo]);
}
}
}
esse arranjo exibe todos os numeros multiplos de 10 desde 15000 até 0
agora, para ele retornar somente os numeros primos nesse período, como eu organizo o comando if?
Tenta assim
public class SemTitulo {
public static void main(String[] arg) {
String linhastr = "";
int a [] = new int[15000];
for(int arranjo = 0; arranjo < a.length; arranjo+=10){
a[arranjo] = a.length - arranjo;
System.out.println(a[arranjo]);
if (a[arranjo]/2==0) {
System.out.println (a[arranjo]);
}
}}
Veja se esta certo pois fiz agora de cabeça nem testei
Vlw
Se achar um número primo fosse assim tão fácil 
Ta aqui
import java.util.*;
class Sieve {
private BitSet bs;
int a = 15000;
public void findPrimes (int a) {
bs = new BitSet (n+1);
int sq = (int) Math.sqrt (n);
// Ao final desta rotina, todos os bits marcados serão primos, e os
// bits desmarcados serão números compostos.
bs.set (0, n, true); // marcando todos os bits como primos...
// Agora vamos achar o primeiro bit primo, e desmarcar todos os bits
// que são múltiplos dele. Vamos começar por 3
int x = 2;
while (x <= sq) {
for (int i = x + x; i <= n; i += x) {
bs.clear (i);
}
// Devemos achar o próximo bit setado que seja maior que x
x = bs.nextSetBit (x + 1);
}
}
public boolean isPrime (int n) {
return bs.get (n);
}
public static void main(String[] args) {
Sieve s = new Sieve();
s.findPrimes (775146);
for (int i = 1; i <= 100; ++i) {
System.out.println (i + " is " + (s.isPrime(i) ? "prime" : "not prime"));
}
}
}
Scoobydoo, o cara eh iniciante!
C mata o véi com isso! =Dpackage guj;
public class SemTitulo {
public static void main(String[] arg) {
//numeros primos de inicial ate final
int ini = 1;//nao coloque menor q 1 senão lá embaixo entra em loop infinito
int fin = 15000;
int atual;
int primo;
for(int i = ini; i <= fin; i++){
primo = 0;
atual = i;
//verifica se é primo
for(int j = atual; j >= 1; j--){
if(atual%j==0){
primo = primo + 1;
}
}
//só é primo se for divisivel por 1 e ele mesmo
if(primo==2){
System.out.println(atual);
}
}
}
}
Usando uma lógica mais simples:
public static void gerarPrimos(int ate) {
int numero=ate;
boolean isPrimo = true;
for(int x=numero;x>1;x--){
if(numero%x == 0){
isPrimo = false;
}else{
isPrimo = true;
}
}
if(isPrimo==true){
System.out.println("O numero "+numero+" é primo.");
}else{
System.out.println("O numero "+numero+" não é primo.");
}
}
Agora é so chamar dentro de cada posição do array:
SemTitulo.gerarPrimos(meuArray[meuIncice]);
Testa ai!
P.S: Fiz aqui mesmo no fórum, sem testar! DA uma olhada!
bão, eu peguei o do fabricio lá em cima, e testei, corrigi uns trancos, e aqui o código
public class SemTitulo {
public static void main(String[] arg) {
String linhastr = "";
int a [] = new int[50];
for(int arranjo = 0; arranjo < a.length; arranjo++){
a[arranjo] = a.length - arranjo;
// System.out.println(a[arranjo]);
if (a[arranjo]/2==0) {
System.out.println (a[arranjo]);
}
}
}
}
//Porém, esse código retorna sempre em 1...
os outros ainda não testei, vo ver agora um por um :D
Iniciante ou não ele tem que aprender…
ah me enganei msm ao inves do / e o %
% = resto da divisão desculpa aew pessoal
Iniciante ou não ele tem que aprender...Verdade.
Como eu disse que poderia fazer usando o array, vou postar aqui uma forma de fazer esta verificação para ajudar ele a entender melhor como seria a implementação. Agora basta juntar com o que ele quer.
/
public class NumerosPrimos {
public static void gerarPrimos(int ate) {
int[] meuArray = new int[ate];
boolean isPrimo = true;
//carrega o array[]
for(int x=0;x<meuArray.length;x++){
meuArray[x]=x;
}
for (int x = 0; x < meuArray.length; x++) {
for (int y = meuArray[x]; y > 1; y--) {
if (meuArray[x] % y == 0) {
isPrimo = false;
} else {
isPrimo = true;
}
}
if(isPrimo==true){
System.out.println("O numero " + meuArray[x] + " é primo.");
}else{
System.out.println("O numero " + meuArray[x] + " não é primo.");
}
}
}
public static void main(String[] arg) {
NumerosPrimos.gerarPrimos(50);
}
}
ah me enganei msm ao inves do / e o %% = resto da divisão desculpa aew pessoal
Iniciante ou não ele tem que aprender…
Valeu pelo complemento da explicação
Acredito que da forma com que fiz seja certa dentro do
problema porém não testei os outro codigos
Valeu abraço
Valeu pelo complemento da explicaçãoAcredito que da forma com que fiz seja certa dentro do
problema porém não testei os outro codigos
Valeu abraço
tá certa sim, só que os primos tem de retornar os restos diferentes de zero(to procurando o simbolo pra isso…)
e um número primo não é divisível nem por 2 nem por 3, mas a lógica é essa mesma, eu vou tentar de novo hj a tarde, botando o if de 3 dentro do if d 2, ou tentar(ainda não fiz, então não posso dizer q sei) usar um else if, ou algo do genero, e imprimindo o resultado.
acho que vai funfa…
anyway, valeu a força gente, eu posto o que eu consegui depois 8)
Outro erro meu
public class SemTitulo {
public static void main(String[] arg) {
String linhastr = "";
int a [] = new int[15000];
for(int arranjo = 0; arranjo < a.length; arranjo+=10){
a[arranjo] = a.length - arranjo;
System.out.println(a[arranjo]);
if (a[arranjo]%2!=0) { // se for diferente de 0 = primo
System.out.println (a[arranjo]);
}
}}
Acho que não errei mais nada ahahuahhua 
<blockquote>Outro erro meu
view plaincopy to clipboardprint?
public class SemTitulo {
public static void main(String[] arg) {
String linhastr = "";
int a [] = new int[15000];
for(int arranjo = 0; arranjo < a.length; arranjo+=10){
a[arranjo] = a.length - arranjo;
System.out.println(a[arranjo]);
if (a[arranjo]/2!=0) { // se for diferente de 0 = primo
System.out.println (a[arranjo]);
}
}}
Acho que não errei mais nada ahahuahhua
Fabricioempresa, assim vc encontrará tds numeros ímpares!
Suponhamos que a[arranjo] seja 9
9/2 = 4.5
4.5 != 0
Dae ele imprime 9, mas 9 n eh primo!
Mesmo se o operador fosse %
9%2 = 1
1 != 0
Logo tb seria impresso! E 9 tb n eh primo!
Essa solução não é tão trivial assim!
Vejam a solução que propus anteriormente!
A do Scoobydoo tb está certa, e mais precisa computacionalmente falando, mas porém mais complexa!
Poh realmente não devo ter lido direito as respostas pois eu realmente so buscava os no ímpares foi mal aew :x
public class SemTitulo {
public static void main(String[] arg) {
String linhastr = "";
int a [] = new int[16];
for(int arranjo = 0; arranjo < a.length; arranjo++){
a[arranjo] = a.length - arranjo;
if (a[arranjo]%2!= 0){
if (a[arranjo]%3!= 0);{
System.out.println (a[arranjo]);
}
}
}
}
}
ele tá sem erros de compilação e tudo, mas quando vc executa ele, ele retorna os numeros multiplos de 5 que são ímpares também, eu imagino que mais um comando if resolva... claro, o 2 não é retornado, pois ele retorna zero quando dividido por 2, mas o 2 é o único primo par tbm...
embora eu tenha gostado do resultado, está longe de ser exato (falta o 2 e precisa de aprimoramentos 8))
Maurício, você não percebeu?
O primeiro cara que lhe respondeu não sabe a diferença entre “ímpares” e “primos”. Não vá na onda dele.
Crie um método que determine se um determinado número é primo ou não (pode ser aquele de ficar dividindo o número, que você viu num dos posts). Aí você chama esse método para cada número.
Outra forma, já que você sabe usar arrays, é o tal do “crivo de Eratóstenes”. Dê uma procuradinha nele, que é o que o professor provavelmente vai querer que você faça.
Alguém está tentando ensinar você que um número é primo se ele não for divisível por 2 ou por 3. Conforme você viu, 5 já dá problemas porque é primo.
Se você for nessa onda, então teste contra os seguintes números, se você quer saber se os números entre 1 e 15000 são primos:
2 , 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113
Se um número não for divisível por nenhum desses números acima, e se ele estiver abaixo de 16128, então ele é primo. (Isso é verdade mesmo).
Só que você viu que isso é meio esquisito, não?
Se por acaso você tentar o algoritmo com o número 16129, que não é primo (na verdade ele é 127 x 127), o seu algoritmo já indicará um resultado incorreto.
Maurício, você não percebeu?O primeiro cara que lhe respondeu não sabe a diferença entre “ímpares” e “primos”. Não vá na onda dele.
Crie um método que determine se um determinado número é primo ou não (pode ser aquele de ficar dividindo o número, que você viu num dos posts). Aí você chama esse método para cada número.
Outra forma, já que você sabe usar arrays, é o tal do “crivo de Eratóstenes”. Dê uma procuradinha nele, que é o que o professor provavelmente vai querer que você faça.
bom… eu vi uma vez em um livro que a regra básica para primos é q ele não é dividido nem por 3 nem por 2, mas isso tá longe de funcionar pra todos os numeros, como no caso dos multiplos d 5…
bom, eu só tenho uma aula ainda, mas eu tenho um material aqui, e vo da uma estudada, depois eu faço com métodos mais exatos.
embora eu ainda não entenda como busca recurso, como nos q utilizam import, eu pego o jeito ;D
vo ver o crivo, depois eu te digo o que saiu disso tudo 
Alguém está tentando ensinar você que um número é primo se ele não for divisível por 2 ou por 3. Conforme você viu, 5 já dá problemas porque é primo.Se você for nessa onda, então teste contra os seguintes números, se você quer saber se os números entre 1 e 15000 são primos:
2 , 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113Se um número não for divisível por nenhum desses números acima, e se ele estiver abaixo de 16128, então ele é primo. (Isso é verdade mesmo).
Só que você viu que isso é meio esquisito, não?
Se por acaso você tentar o algoritmo com o número 16129, que não é primo (na verdade ele é 127 x 127), o seu algoritmo já indicará um resultado incorreto.
tbm é verdade, pois no livro que eu vi isso, dizia explicitamente que não servia para todos os numeros. se eu não me engano eram os números até 100, eu acho, tem mto tempo q eu li o tal livro.
isso apresenta mtas falhas, mas calma, é só minha 1° aula, eu vo estudar mais
Teorema de Wilson.
Dado um número p, se (p - 1)! + 1 mod p = 0, o número é primo.
boolean isPrime(long p) {
if ((fatorial(p - 1) + 1) % p == 0) return true;
return false;
}
long fatorial(long n) {
if (n <= 1L) return 1;
else return n * fatorial(n - 1); // Fatorial recursivo...
}
Não é o algoritmo mais eficiente, mas funciona.
Há um problema com essa implementação, por parte do fatorial. Número muito grande para o tipo de dado.
Funciona corretamente para p <= 19. Uma implementação utilizando BigInteger deve funcionar perfeitamente com qualquer número.
O símbolo para saber o resto de uma divisão é %
8%2 = 0 (o resto é 0)
9%2 = 1 (o resto é 1)
Pessoal, e principalmente Mauricio1993:
Como vc disse q eh iniciante, está “aprendendo” Java, provavelmente o que o seu professor quer é treinar estruturas de repetição aninhadas e lógica de programação.
A definição de número primo é:
Um número natural, que possua exatamente dois divisores: 1 e ele mesmo!
Como é natural, deve ser um número inteiro não-negativo, ou seja, de 0 acima.
0 não é primo, pq eh divisível somente por 1 (0/0 é indeterminado)
1 tb não é, pq é divisível por 1, ou por ele mesmo, ou seja, só tem 1 divisor!
2 é primo, e é o único par primo! divisível somente por 1 e ele mesmo!
Seguindo esta lógica, como saber se 2101 é primo?
Há diversos teoremas e formas, como muitos já falaram, mas como vc está iniciando, vai fazer na força bruta mesmo!
Seja x o numero a testar,
x%(x-1)!=0
x%(x-2)!=0
x%(x-3)!=0
x%(x-4)!=0
(…)
x%2!=0
Se tudo isso for != 0, é primo! senão, não é!
Mas como fazer isso? com um for (como propus anteriormente)
Acredito que seu problema não esteja na programação, nem no Java, e sim na definição de número primo!
Qualquer dúvida tamus aki!
então. foi justamente isso que ele me disse. Que se um numero primo é um número q só tem 2 divisores (ele mesmo e 1) então com 3 comandos de divisão eu poderia achar ele. e também me disse que uma forma de se fazer era usando o comando if, mas eu não tenho certeza de COMO implementar esses comandos, dai me lembrei do tal livro. quase deu certo, mas definitivamente a precisão de tal coisa é deplorável.
de qualquer jeito eu vo ver o que dá pra ser feito, e vo testa o código que tu propos.
só não sei se vo pode faze isso hj, por causa das aulas (ensino médio) que logo logo tão me tirando de casa.
qualquer coisa eu faço de madru e posto amanhã cedo
meus 2 centavos:
public class CrivoEratostenes {
public static void main(String[] args) {
List<Integer> primos = new ArrayList<Integer>();
List<Integer> removidos = new ArrayList<Integer>();
StringBuilder resultado = new StringBuilder("Primos: ");
int qtd = Integer.parseInt(JOptionPane.showInputDialog("Entre com o Nº máximo a ser verificado:"));
Long time1 = System.currentTimeMillis();
for(int i = 2; i <= qtd; i++){
primos.add(i);
}
removidos.addAll(primos);
for(Integer primo : primos){
if(primo == 2 || primo == 3 || primo ==5) continue;
if(primo%2 == 0){ removidos.remove(primo); }
if(primo%3 == 0 && removidos.contains(primo)){ removidos.remove(primo); }
if(primo%5 == 0 && removidos.contains(primo)){ removidos.remove(primo); }
}
for(Integer primoRes : removidos){
resultado.append(primoRes + ", ");
}
System.out.print(resultado.deleteCharAt(resultado.length()-2));
Long time2 = System.currentTimeMillis();
System.out.println("Tempo de execução: " + (time2 - time1) + " ms");
}
}
Coloquei o temporizador só pra ver se não iria ficar lento demais e validar a eficácia do código…
Abs []
Credo, não pensei que você também era da mesma religião que acredita que qualquer número que não seja divisível por 2, 3 e 5 é primo.
Essa religião é do mal; não é a mesma que acreditava que o número pi era exatamente igual a 3, porque depois ela se corrigiu.
49 é primo?
meus 2 centavos:
Credo, não pensei que você também era da mesma religião que acredita que qualquer número que não seja divisível por 2, 3 e 5 é primo.
Essa religião é do mal; não é a mesma que acreditava que o número pi era exatamente igual a 3, porque depois ela se corrigiu.
49 é primo?
Cara… PQP… quase me enterrei de vergonha. Lí a merda do algoritmo e implementei de forma IDIOTA… tbm, peguei pra fazer em paralelo com a geração de uma versão para a Produção aqui no trampo… se tu não falasse, eu ia passar lotado… CARACAAAAAAAAAAAAAAAAA que coisa mais idiota… Não responderei mais com pressa aqui no fórum…
Segue meus 3 centavos agora… Espero que não tenha deixado escapar nada dessa vez… testei com valor 30 e testei com valor 100…
public class CrivoEratostenes {
public static void main(String[] args) {
List<Integer> primos = new ArrayList<Integer>();
List<Integer> removidos = new ArrayList<Integer>();
StringBuilder resultado = new StringBuilder("Primos: ");
Integer qtd = Integer.parseInt(JOptionPane.showInputDialog("Entre com o Nº máximo a ser verificado:"));
int baseVerificacao = (int)Math.sqrt(qtd.doubleValue());
for(int i = 2; i <= qtd; i++){
System.out.println("Adicionando: " + i);
primos.add(i);
}
removidos.addAll(primos);
int base = 0;
int contBase = 0;
System.out.println("Removendo Multiplos...");
while(base <= baseVerificacao){
base = removidos.get(contBase);
for(Integer primo : primos){
if(primo != base && primo%base == 0){
System.out.println("Remover: {" + primo + "} Base: " + base);
removidos.remove(primo);
}
}
primos = new ArrayList<Integer>(removidos);
contBase++;
}
System.out.println("Resultado: ");
for(Integer primoRes : removidos){
resultado.append(primoRes + ", ");
}
System.out.print(resultado.deleteCharAt(resultado.length()-2));
}
}
E respondendo… não, 49 não é primo… rsrs
PQP… fods mesmo… fiquei pra baixo com essa…
Não tem problema. Só lembrar que “remove” é uma operação lenta em um ArrayList, ainda mais que você está usando a versão que remove por objeto - ele tem de procurar no array inteiro até encontrar. Alguém aqui no GUJ implementou usando um BitSet - que tal dar uma olhada nessa versão?
tô por dentro… hueheueheueheuehu fiz o mais prático só pra redimir a cagada anterior…
Não conheço bem o BitSet… mas vou dar uma olhada…
abs []