Multiplos de 11 e pares e imapres entre 100 e 200

Programação Java
#1

bleza pessoal
eu sou novo no java e estou com dificuldade para jazer esse programa
que gere e escreva na tela os numeros pares, impares e multiplos de 11 entre 100 e 200
eu gostaria de umas dicas ou algum exemplo eu ja fiz uma parte mas ele retorna 00 em todos os valore
segue o codigo que eu fiz

public static void main (String args[]){

  int cont;   
  int impar = 0;   
  int par = 0;   
  int mult = 0;   
     
  for (cont = 100; cont <= 200; cont++);{   
  if (cont % 11 ==0)   
     cont = cont + mult;   
              
  if (cont % 2 == 0)   
     cont = par + cont;   
     par ++;   
  if (cont % 2 != 0)   
     cont = impar + cont;   
        impar++   ;      
   System.out.println("Os número multiplos de  11 entre 100 e 200 são: " + mult);   
  System.out.println("Os número pares entre 100 e 200 são: " + par);   
  System.out.println("Os número impares entre 100 e 200 são: " + impar);   
     
  }

}
public static void main (String args[]){

  int cont;
  int impar = 0;
  int par = 0;
  int mult = 0;
  
  for (cont = 100; cont <= 200; cont++);{
  if (cont % 11 ==0)
     cont = cont + mult;
           
  if (cont % 2 == 0)
     cont = par + cont;
     par ++;
  if (cont % 2 != 0)
     cont = impar + cont;
        impar++   ;   
   System.out.println("Os número multiplos de  11 entre 100 e 200 são: " + mult);
  System.out.println("Os número pares entre 100 e 200 são: " + par);
  System.out.println("Os número impares entre 100 e 200 são: " + impar);
  
  }

}

#2

Well, você poderia tentar mudar os valores de impar, par e mult…

#3

Cara, se eu entendi direito vc quer mostrar uma String contendo cada tipo. Desta forma que você está fazendo, no máximo, você somaria os valores e mostraria esta soma. Claro, isso caso você estivesse fazendo da maneira correta.

Em primeiro lugar, você está utilizando um inteiro para armazenar cadeia de caracteres.
Em segundo lugar você está jogando dentro de count os valores da soma e não dentro de mult, etc.

O ideal seria usar um ArrayList e depois mostrar o que você quer. Mas se tiver dificuldades, troca as variáveis int impar = 0; int par = 0; int mult = 0; para String. Utilize algum caracter separador e sai acrescentando os valores nessas Strings, através dos resultados dos ifs, que parecem estar corretos.

Cara, a princípio, foi somente isso que notei. Eu poderia montar o código para você, mas, dessa forma, você não aprenderia nunca.

Dá uma reforçada em lógica, acho importante.

Abraços.

#4

[quote=celso.martins]Cara, se eu entendi direito vc quer mostrar uma String contendo cada tipo. Desta forma que você está fazendo, no máximo, você somaria os valores e mostraria esta soma. Claro, isso caso você estivesse fazendo da maneira correta.

Em primeiro lugar, você está utilizando um inteiro para armazenar cadeia de caracteres.
Em segundo lugar você está jogando dentro de count os valores da soma e não dentro de mult, etc.

O ideal seria usar um ArrayList e depois mostrar o que você quer. Mas se tiver dificuldades, troca as variáveis int impar = 0; int par = 0; int mult = 0; para String. Utilize algum caracter separador e sai acrescentando os valores nessas Strings, através dos resultados dos ifs, que parecem estar corretos.

Cara, a princípio, foi somente isso que notei. Eu poderia montar o código para você, mas, dessa forma, você não aprenderia nunca.

Dá uma reforçada em lógica, acho importante.

Abraços.

[/quote]

obrigado pela ajuda mas ainda nao consegui resolver e entender muito bem mudei o codigo ficou assim

public static void main (String args[]){

	int cont;
	String impar;
	String par;
	String mult;
	
	for (cont = 100; cont <= 200; cont++);{
	if (cont % 11 ==0)
		mult = cont + mult;
				
	if (cont % 2 == 0)
		par = par + cont;
		
	if (cont % 2 != 0)
		impar = impar + cont;
        	
	System.out.println("Os número multiplos de  11 entre 100 e 200 são: " + mult);
	System.out.println("Os número pares entre 100 e 200 são: " + par);
	System.out.println("Os número impares entre 100 e 200 são: " + impar);
	
	}		
	
}
#5

[quote=jhecko][quote=celso.martins]Cara, se eu entendi direito vc quer mostrar uma String contendo cada tipo. Desta forma que você está fazendo, no máximo, você somaria os valores e mostraria esta soma. Claro, isso caso você estivesse fazendo da maneira correta.

Em primeiro lugar, você está utilizando um inteiro para armazenar cadeia de caracteres.
Em segundo lugar você está jogando dentro de count os valores da soma e não dentro de mult, etc.

O ideal seria usar um ArrayList e depois mostrar o que você quer. Mas se tiver dificuldades, troca as variáveis int impar = 0; int par = 0; int mult = 0; para String. Utilize algum caracter separador e sai acrescentando os valores nessas Strings, através dos resultados dos ifs, que parecem estar corretos.

Cara, a princípio, foi somente isso que notei. Eu poderia montar o código para você, mas, dessa forma, você não aprenderia nunca.

Dá uma reforçada em lógica, acho importante.

Abraços.

[/quote]

obrigado pela ajuda mas ainda nao consegui resolver e entender muito bem mudei o codigo ficou assim

public static void main (String args[]){

	String impar;
	String par;
	String mult;
	
	for (int cont = 100; cont <= 200; cont++);{
	if (cont % 11 ==0)
		mult = cont + mult;
				
	if (cont % 2 == 0)
		par = par + cont;
		
	if (cont % 2 != 0)
		impar = impar + cont;
        	
	System.out.println("Os número multiplos de  11 entre 100 e 200 são: " + mult);
	System.out.println("Os número pares entre 100 e 200 são: " + par);
	System.out.println("Os número impares entre 100 e 200 são: " + impar);
	
	}		
	
}

[/quote]

public static void main (String args[]){

int cont;
String impar = "";
String par = "";
String mult = "";

for (cont = 100; cont <= 200; cont++) {

if (cont % 11 ==0)
mult += cont + ", ";

if (cont % 2 == 0)
par +=  cont + ", ";

if (cont % 2 != 0)
impar += cont + ", ";

}

System.out.println("Os número multiplos de 11 entre 100 e 200 são: " + mult);
System.out.println("Os número pares entre 100 e 200 são: " + par);
System.out.println("Os número impares entre 100 e 200 são: " + impar);

}
#6

Obrigado Foxlol e Celso vcs me ajudaram muito
resolvido Obrigado mesmo

#7

Entrei só como curiso e tirei uma duvida tbm :D, vlw pessoas.

#8

Ok. Agora vamos pensar um pouco.

Há uma forma de resolver esse problema percorrendo um pouco mais da metade dos números.
Ei-la:

Set<Integer> pares = new TreeSet<Integer>();
Set<Integer> impares = new TreeSet<Integer>();

//pulamos de 2 em 2. Assim percorremos só 50 números, não 100.
//Afinal, todo número par é escrito na forma 2*n. E os ímpares na forma 2*n-1 (ou 2*n+1)
pares.add(100);
for (int cont = 102; cont <= 200; cont+=2) { 
   pares.add(cont);
   impares.add(cont-1);
}

//Pulamos de 11, já começando de 110. 
//Assim percorremos 8 números (de 11x10=110 até 110+11x8=198).
Set<Integer> multiplosDeOnze = new TreeSet<Integer>();
for (int cont = 110; cont <= 200; cont+=11) {
   multiplosDeOnze.add(cont);
}

System.out.println("Pares: " + pares);
System.out.println("Impares: " + impares);
System.out.println("Multiplos de 11:" + multiplosDeOnze);

Esse algoritmo percorre 58 elementos. O anterior, 100. Além disso, ele nem faz duas operações de resto e nem dois ifs a cada iteração e, certamente, terá um ganho de performance superior a 100%.

Gosto de postar códigos assim, em problemas simples como esse, porque acredito que é bom abrir a cabeça. É sempre legal mostrar que você tem a solução óbvia, e uma solução melhor, tão elegante quanto, mas nem sempre tão óbvia assim.

PS: Não testei o código, então talvez ele tenha algum errinho. Mas já serve para demonstrar o que eu queria. :wink:

#9

ai vem o vinyGodoy dando Show de bola…

aproveitei esta ideia dos Sets para Optmizar o meu Codigo de Grafos… :twisted:

#10

[quote=ViniGodoy]…[code]
//Pulamos de 11, já começando de 110.
//Assim percorremos 8 números (de 11x10=110 até 110+11x8=198).
Set multiplosDeOnze = new TreeSet();
for (int cont = 110; cont <= 200; cont+=11) {
multiplosDeOnze.add(cont);
}

System.out.println("Pares: " + pares);
System.out.println("Impares: " + impares);
System.out.println(“Multiplos de 11:” + multiplosDeOnze);
[/code]
…[/quote]
A maneira que o ViniGodoy colocou está correta, mas e se quisermos generalizar para qualquer múltiplo e qualquer intervalo? Poderemos utilizar congruências!

Se quiseres saber todos os múltiplos de 53 dentro do intervalo 99384 até 121223, terás que:

  • achar o resto da divisão de 99384 por 53 ( assim achamos a posição do início do intervalo em relação ao múltiplo de 53 ). Nesse caso 9. Com isso sabemos que 53 vezes algum número, mais 9 dá 99384. Para achar o primeiro valor dentro desse intervalo, façamos 99384 +(53-9) = 99428.
  • achar o resto da divisão de 121223 por 53 ( assim achamos outra posição equivalente ). Nesse caso 12. Então quer dizer que algum número vezes 53, tudo isso mais 12 dá 121223. Então o último múltiplo é 121223-12 = 121211.
    Agora que sabes qual é o início e fim do intervalo de iteração e o passo da iteração, consegues fazer um for do início até o fim somando o passo. Deixo isso para alguém implementar. Lembro que isso funciona para qualquer intervalo inteiro.

Até!

#11

Na verdade, só é necessário achar o início real da iteração.

Outra forma de fazer isso é o seguinte:

  • Divida 99384 por 53 (divisão inteira). Depois multiplique o resultado por 53 novamente. Se for < 99384 some 53.

O final da iteração não precisa necessariamente ser encontrado. O for funciona normalmente se vc fizer a condição <= 121223.

O algoritmo ficaria assim:

public Set<Integer> calcularMultiplos(int inicio, int fim, int num) {
   int inicioReal = (inicio / num) * num;
   if (inicioReal < inicio) 
      inicioReal += num;

   Set<Integer> numeros = new TreeSet<Integer>();
   for (int i = inicioReal; i <= fim; i += passo) {
      numeros.add(i);
   return numeros;
}

Note que mesmo no caso do cáculos dos pares e ímpares, fazendo duas chamadas a função, esse algoritmo ainda é mais eficiente que o primeiro demonstrado.
Ele percorre o mesmo número de elementos, mas não faz comparações e nem divisões a cada iteração do laço. Divisão é uma operação cara para os processadores.

#12

Ah, sim. Não precisa nesse caso de limite superior fechado, pode-se trabalhar com o aberto. Mas caso queira extrapolar o uso dessa idéia, é bom trabalhar com o intervalo fechado ( como separar em classes números de mesmo módulo mas cada classe com o mesmo número de elementos ).

Até!

#13

[quote=ViniGodoy]Ok. Agora vamos pensar um pouco.

Há uma forma de resolver esse problema percorrendo um pouco mais da metade dos números.
Ei-la:

[code]
Set pares = new TreeSet();
Set impares = new TreeSet();

//pulamos de 2 em 2. Assim percorremos só 50 números, não 100.
//Afinal, todo número par é escrito na forma 2n. E os ímpares na forma 2n-1 (ou 2*n+1)
pares.add(100);
for (int cont = 102; cont <= 200; cont+=2) {
pares.add(cont);
impares.add(cont-1);
}
[/code][/quote]

Em questão de otimização, é capaz do código acima ter perfomance pior que o abaixo.

[code]
Set pares = new TreeSet();

for (int cont = 100; cont <= 200; cont+=2) {
pares.add(cont);
}

Set impares = new TreeSet();

for (int cont = 101; cont <= 200; cont+=2) {
impares.add(cont);
}[/code]

Isso por que por conter mais instruções dentro do loop. o primeiro código pode acabar que fazer mais paginações para obter a próxima parte a ser executada do código. O segundo executa menos instruções no loop que o primeiro. Isso sem falar que no segundo, um compilador bom pode paralelizar a tarefa(se bem que um melhor faria o mesmo com o primeiro).

#14

[quote=Bruno Laturner]…

Em questão de otimização, é capaz do código acima ter perfomance pior que o abaixo.

[code]
Set pares = new TreeSet();

for (int cont = 100; cont <= 200; cont+=2) {
pares.add(cont);
}

Set impares = new TreeSet();

for (int cont = 101; cont <= 200; cont+=2) {
impares.add(cont);
}[/code]

Isso por que por conter mais instruções dentro do loop. o primeiro código pode acabar que fazer mais paginações para obter a próxima parte a ser executada do código. O segundo executa menos instruções no loop que o primeiro. Isso sem falar que no segundo, um compilador bom pode paralelizar a tarefa(se bem que um melhor faria o mesmo com o primeiro).[/quote]
Er… Não. O mais caro é o passo de loop. Fazer com que ele faça mais instruções por passo, nesse caso, é mais interessante do que fazer com que ele faça duas vezes da mesma iteração (digo que é a mesma porque como já foi dito, os números são escritos como 2k+0 e 2k+1). Quase nenhum compilador é intrusivo o suficiente para adivinhar o uso e fazer com que as tarefas sejam “reutilizadas”.
Quanto mais você conseguir colocar tarefas dentro de um laço qualquer, melhor para quase qualquer tipo de ação. Mandar fazer as mesma coisa duas vezes, e pior, sem uma refinação pode ser muito prejudicial para qualquer aplicação.

Até!

#15

É, minha intuição diz que a cache do processador é levada em conta nesta análise, mas não estou conseguindo montar o raciocínio lógico completo do que quero dizer, hehehehe…Tempo demais programando deixa a gente maluco.

Mas enfim…A relação entre a quantidade de dados manipulados por iteração e a cache é relevante…

#16