Potências de 2

Programação Java
#1

Olá!
Tenho que fazer um algoritmo que identifique quais os números que são potências de 2.
Consegui implementar, só que só são identificadas as potências a partir de 4. Porém, 1 e 2 também são potências.
Alguém pode me dar uma dica sobre o que fazer para os números 1 e 2 serem identificados?
Obrigada!

package filter;

/**classe que filtra as potências de 2
 * 
 * @author Kamilla
 *
 */
public class FiltraPot2 extends Filtra{

	//**método para filtrar as potências de 2*/
	boolean aceita(int x) {
		
		int cont=x;
		int filt=0;
		
	for(cont =x ; cont >=2; cont--){
			x = x/2;
			filt = x;
			cont=x;
	}
			if((filt!=2) || (filt>2))
				return false;
			
			else
				return true;
			
				}
	
	
	public static void main(String[] args) {
		Filtra f = new FiltraPot2();
		
		f.FiltraInt(2);
		f.FiltraInt(3);
		f.FiltraInt(7);
		f.FiltraInt(4);
		f.FiltraInt(1);
		f.FiltraInt(8);
		f.FiltraInt(16);
		f.FiltraInt(32);
		f.FiltraInt(64);
		f.FiltraInt(128);
	}

	

}

O console mostra:

4
8
16
32
64
128
#2

talvez se vc fizesse um if e um esle if para o 1 e 2 não funcionaria?

#3

Sim, pensei nisso… Só que no else e depois if teria que ser agor tipo…

[code]for(cont = x ; cont >=2; cont–){
x = x/2;
filt = x;
cont=x;
}
if((filt!=2) || (filt>2))
return false;

		else
			if((filt==1) || (filt==2))
			return true;
			
			}

[/code]

E daí eu tenho erro…

[code]Exception in thread “main” java.lang.Error: Unresolved compilation problem:
This method must return a result of type boolean

at filter.FiltraPot2.aceita(FiltraPot2.java:11)
at filter.Filtra.FiltraInt(Filtra.java:15)
at filter.FiltraPot2.main(FiltraPot2.java:34)

[/code]

=/

#4

não sua sitaxe seria assim

if () {

}else if(){

}else{

}

#5 
	for(cont = x ; cont >=2; cont--){
			x = x/2;
			filt = x;
			cont=x;
	}
			if((filt!=2) || (filt>2))
				return false;
			else
				if((filt==1)||(filt==2))
				return true;
				else
					return false;
				
				}
4
8
16
32
64
128
256

Continua sem aparecer o 1 e o 2… T.T

#6

Oi Camila
Num sei se vai funcionar, mas eu faria assim

//faria a verificação no inicio
if((filt==1)||(filt==2))  
            return true; 
//aqui não é necessário verificar se é igual a dois pois o caso foi verificado acima
//  for(cont =x ; cont >=2; cont--){  
  for(cont =x ; cont >2; cont--){  
            x = x/2;  
            filt = x;  
            cont=x;  
    }  
//aqui não é necessário verificar se é diferente de dois pois o caso foi verificado acima
//  if((filt!=2) || (filt>2))  
   if(filt>2)
           return false;  
   else  
           return true;  
}

Porém, se você quiser manter do jeito que fez pode fazer o seguinte, talvez o retorno do else if esteja invertido

 if(filt>2) 
            return false;  
 else  if((filt==1)||(filt==2))  
            return true;  
 else  
            return true;
            }

E tire o igual do for senão ele vai dividir o 2 por 2 e vai dar 1.

for(cont = 2 ; cont >=2; cont--){  
            2 = 2/2;  
            filt = 1;  
            cont=1;  
    }

Tenta usar o debug com breakpoint para verificar, ajuda bastante.
Espero ajudar.
Abraços, Alan

#7

Obrigada, Alan! Deu certo!
Só que… eu estava perdendo a precisao dos números, daí alguns que tinha 2.895 era passados como true. Resolvi colocando float em todos, acontece que alguns números ainda continuam com o mesmo problema e eu não consigo idenficar o motivo…
Alguém pode me ajudar?
Obrigada!

if((filt==1.000f)||(filt==2.000f)){
			return true;
		}
			

		
	for(cont = x ; cont>2.000f; cont--){
			x = (x/2.000f);
			cont = x;
			filt = x;
	}
		
		
		if((filt>2.000f)){
			return false;
			}
		else
				return true;
		}

	
	public static void main(String[] args) {
		Filtra f = new FiltraPot2();
		
		f.FiltraInt(1);
		f.FiltraInt(2);
		f.FiltraInt(3);
		f.FiltraInt(7);
		f.FiltraInt(4);	
		f.FiltraInt(8);
		f.FiltraInt(16);
		f.FiltraInt(32);
		f.FiltraInt(64);
		f.FiltraInt(128);
		f.FiltraInt(256);
		f.FiltraInt(5);
		f.FiltraInt(23);
		f.FiltraInt(12);
		f.FiltraInt(11);
		f.FiltraInt(512);
		f.FiltraInt(13);
	}
}

No console:

1.0
2.0
3.0
7.0
4.0
8.0
16.0
32.0
64.0
128.0
256.0
512.0
13.0
#8

Olá,

Talvez você queira/precisa resolver do seu jeito, provavelmente isso é um exercisio de lógica, e se for o caso, favor ignorar minha sugestão:

No mundo binário, as potências de 2 têm uma caracteristica que é que eles tem exatamente um bit setado, o resto são zeros.

dec 1 = bin 1
dec 2 = bin 10
dec 4 = bin 100
dec 8 = bin 1000
…
e assim pra frente. A classe Integer tem um método que diz quantos bits setados tem num número. Portanto seu método poderia ser definido assim (ele funciona para valores positivos. Só dá resultado errado para -2147483648) :

    boolean aceita(int x) {
        return Integer.bitCount(x) == 1;
    }

[]s,
Sami

#9

Ótimo! Deu certinho… Obrigada!
Mas… eu ainda queria saber o motivo de eu estar perdendo a precisão naquela outra implementação… Achei bastante estranho pois a precisão só é perdida para determinados números… =S

#10

Olá,

Acho que está o problema está na lógica.

Para mim, isso parece dar o resultado correto:

[code] // *método para filtrar as potências de 2/
boolean aceita(float x) {
float filt = x;
float cont = 0;
if ((filt == 1f) || (filt == 2f)) {
return true;
}

	for (cont = x; cont > 2.000f;) {
		x = (x / 2.000f);
		cont = x;
		filt = x;
	}

	if ((filt < 2.000f)) {
		return false;
	} else
		return true;
}

[/code]

Eu tirei o cont-- do for, e invertei a regra do if final. (linha 15 nesse exemplo)

[]s,
Sami

#11

Sim, deu certo! =D
Só que o 1 e o 2 continuam de fora… T.T

#12

HAHA! Consegui! xD

Obrigada, gente!

#13