Como elevar um 10 na potencia 3 sem usar nenhuma classe da API (na mao mesmo)

Programação Java
#1

Pessoal
eu tenho uma Var que vale 3
e quero elevar 10 na potencia 3 mas usando a Var
dizem q em C é assim
10^3
mas em java nao funfou, nem como acabei de mostrar muito menos assim: 10^Var

ajuuuda ai mundo java :lol:

#2

é só fazer um for …

#3

bom ideia
nao tinha pensado nisso
vou tentar

#4

x elevado a y --> Math.pow (x, y)

#5

naonao amigo
eu tenho de fazer na mao - sem usar nehuma classe

#6

Então a idéia do for resolve de boa.

#7

eu estou tentando fazer com o FOR mas ainda desejo aprender o operador pra potenciação sem usar nenhuma classe da API
pra falar a verdade que que o FOR nao se aplica bem no código que to montando, que é pra converter String em Inteiro

String s = "2345";
		char[] arrayChar = new char[4];
		int[] arrayInt = new int[4];
		int inteiro;
		int soma = 0;
		
		for (int i=0; i<=arrayChar.length-1; i++){
			arrayChar[i] = s.charAt(i);
			arrayInt[i] = arrayChar[i] - '0';
			inteiro = arrayInt[i];
			for (int x = arrayInt.length-2; x>=0; x--) // algo esta errado aqui
				{inteiro = inteiro *10;}
			soma += inteiro;
			System.out.println(inteiro);
		}
		System.out.println("O inteiro e: " + soma);

a String é 2345
sendo assim
deveria gerar:
2000
300
40
5
o inteiro é: 2345

mas gera
2000
3000
4000
5000
0 inteiro 14000

to achando que com o FOR nao da pra fazer

#8

O correto, no seu caso, é separar o código que calcula a potência de 10 em um método separado. Isso evita que você tenha problemas com variáveis que ficam com valores “sujos” de uma outra iteração do seu código.
Crie um método mais ou menos assim:

private int potenciaDe10 (int n) {
    int p = 1;
    for (int i = 1; i <= n; ++i) {
        p = p * 10;
    }
    return p;
}

e chame esse método dentro do seu código, em vez de fazer um loop dentro do outro. A vantagem de fazer assim é que dá para testar separadamente se você está fazendo as coisas direitinho.

#9

[quote=entanglement]O correto, no seu caso, é separar o código que calcula a potência de 10 em um método separado. Isso evita que você tenha problemas com variáveis que ficam com valores “sujos” de uma outra iteração do seu código.
Crie um método mais ou menos assim:

private int potenciaDe10 (int n) {
    int p = 1;
    for (int i = 1; i <= n; ++i) {
        p = p * 10;
    }
    return p;
}

e chame esse método dentro do seu código, em vez de fazer um loop dentro do outro. A vantagem de fazer assim é que dá para testar separadamente se você está fazendo as coisas direitinho. [/quote]

bela pratica, grande aprendizado pra algoritmozinho qualquer. ate com um programinha xula surgem oportunidades de aprender conceitos importantes.
obrigado
vou implementar aqui

#10

Oi, rafaelczy!

Vou te dar duas opções de cálculo para potenciação, uma utilizando recursividade e outra não.
Caso você não esteja familiarizado com o conceito de recursividade, vou te passar uns links: http://www.guj.com.br/java/219751-recursividade e http://pt.wikipedia.org/wiki/Recursividade.

Abaixo, a potenciação SEM o uso de recursividade:

[code] private static int potencia(int base, int expoente)
{
int resultado = 1;
for(int i = 0; i < expoente; i++)
resultado = resultado * base;

  return resultado;
}[/code]

E agora a potenciação COM o uso de recursividade:

private static int potenciaRecursiva(int base, int expoente){ if(expoente ==0) return 1; else return base * potenciaRecursiva(base, expoente-1); }

E a main para testar:

[code] public static void main(String[] args){
int base=10;
int expoente;

	Scanner in = new Scanner(System.in);
	
	System.out.println("Entre com o expoente: ");
	expoente = in.nextInt();

	System.out.println("O resultado sem recursividade é: " + potencia(base, expoente));
	System.out.println("O resultado com recursividade é: " + potenciaRecursiva(base, expoente));
}[/code]

Note que o cáculo da potenciação sem recursividade é uma barbada! Haha, porém, não adianta utilizar recursividade se você não entende o conceito.
Espero que seja útil!

#11

[quote=rafaelczy][quote=entanglement]O correto, no seu caso, é separar o código que calcula a potência de 10 em um método separado. Isso evita que você tenha problemas com variáveis que ficam com valores “sujos” de uma outra iteração do seu código.
Crie um método mais ou menos assim:

private int potenciaDe10 (int n) {
    int p = 1;
    for (int i = 1; i <= n; ++i) {
        p = p * 10;
    }
    return p;
}

e chame esse método dentro do seu código, em vez de fazer um loop dentro do outro. A vantagem de fazer assim é que dá para testar separadamente se você está fazendo as coisas direitinho. [/quote]

Bom segui seu conselho e consegui montar tudo e rodar legal
Se alguem quiser comentar o que mais eu poderia aperfeiçoar agradeço. Agora quero aprender isso sem arrays.

public class Teste4 {
	/**
	 * @param args
	 * @return 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "2345";
		char[] arrayChar = new char[4];
		int[] arrayInt = new int[4];
		int inteiro;
		int expoente = arrayInt.length-2;
		int soma = 0;
		
		for (int i=0; i<=arrayChar.length-1; i++){
			arrayChar[i] = s.charAt(i);
			arrayInt[i] = arrayChar[i] - '0';
			inteiro = arrayInt[i]*Potenciacao.calculaPotenciacao(expoente);
			expoente--;
			soma += inteiro;
			System.out.println(inteiro);
		}
		System.out.println("O inteiro e: " + soma);
	}
}

A classe que calcula potencia:

public abstract class Potenciacao {
	
	public static int calculaPotenciacao (int num){
		int potenciado = 1;
		for (int i=0; i<=num; i++){
			potenciado = potenciado * 10 ;
		}
		return potenciado;
	}
}

Agora ta tri tri pois a entrada e uma string 2345
e a saida é:
2000
300
40
5
O inteiro e: 2345

valeu a ajuda de todos

#12