Falta lógica

Faça uma série de loops encadeados. Ou melhor, no primeiro verifique qual é o número do expoente. Caso seja cinco faço um loop cinco vezes. Dentro deste loop você tem outro que verifica qual o valor da base e soma a si mesma o seu valor tantas vezes quanto for o seu valor.

Algo assim...

int base = 10;
int expoente = 3;
int result = 0;

for(int x = 0; x < expoente; int++){
    for(int y = 1; y < base; int++){
         result = result + base;
   }
}

Não testei isso... deve ter erros, inclusive alguma coisa de lógica no segundo loop...

fica a sugestão

Gustavo Guilherme BacK

Poste o problema na integra… só com essas informações não dá para focar no problema… e vai gerar varias opniões diferentes que talvez não sirva para a resolução da mesma…

Fiz um pequeno algorítmo, espero que ajude…

-Declarar inteiros indice,soma, contador,potencia, total
-Receber potencia
-Receber indice
-soma=0
-total=0

-enquanto potencia>1 faça
-contador:=indice
-enquanto contador>0 faça
-soma=soma+indice
-contador=contador-1
-fim enquanto
-total=total+soma
-potencia=potencia-1
-fim enquanto
-imprima total

Não testei ao certo, mas acho que é isso…
t+

import java.io.*;

 public class Potencia{
 public static void main(String []args){
  String b,e;
  try{
  BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 
  System.out.println("Digite base");
   b=in.readLine();
   int x=Integer.parseInt(b);
  System.out.println("Digite expoente");
   e=in.readLine();
   int y=Integer.parseInt(e);
    
  System.out.println("Resultado:"+expo(x,y));
     }
  catch(Exception exp){
  	exp.printStackTrace();
  	}   
  
  }//fim do main
 public static int expo(int base,int expoente){
  if(expoente==0)
   return 1;      
  else
   if(expoente==1)
    return base;  
   else
    return base * expo(base,expoente-1);
                                        }//fim expo 
 
  
}//fim de potencia

expo :: Int->Int->Int
 expo b e 
       | e == 0 = 1
       | e == 1 = b
       | otherwise = b * expo b(e-1)

Espero q ajude! :wink:

Opa…
valeu pela ajuda galera…
consegui em C

main(){
   int base, mult, exp;
   int cont1, cont2;
   int resul = 0;

   base = 6;
   exp = 3;

   cont1 = base;
   cont2 = exp;
   while (cont2 > 1){
      resul = 0;
      while(cont1 > 0){
        resul += base;
        cont1--;
      }
      cont1 = resul;
      cont2--;
   }
   printf("%i",resul);
}

o segredo tava naquele cont1 = resul

agora tenho que correr para transcrever para assembly… valeu!

somente soma e subtração? não pode usar deslocamento (shifts) e operadores lógicos?
com isso é trivial implementar multiplicação e depois exponenciação.

multiplicação de 16 bits:

short mul(short a, short b) {
   short r = 0;
   for(int i = 0 ; i < 16; ++i)
     if((b >> i) & 0x1 == 1) r += a << i;
     //ou  r += (a << i) & 0 - ((b >> i) & 0x1);
   return r;
}

short exp(short x, short e) {
   short r = 1;
   while(e-- > 0)
      r = mul(r, x);
   return r;
}

porem se voce pode utilizar somente soma tua função mul ficaria:

short mul(short a, short b) {
   short r = 0;
   while(b-- > 0) r += a;
    return r;
}

Transformar essas funções em assembly é trivial.

Ay,Caramba!Agora q eu li q não era pra usar nenhuma multiplicação!
Pensei q era só pra fazer recursivamente…foi malz,guscoppi
Tô mexendo com Haskell D+…

“Ironlynx”:

Ay,Caramba!Agora q eu li q não era pra usar nenhuma multiplicação!
Pensei q era só pra fazer recursivamente…foi malz,guscoppi
Tô mexendo com Haskell D+…

Andei lendo o site do Haskell e achei muito interessante…
Quanto tempo você demorou ± pra “pegar o esquema” da programação funcional??

“Ironlynx”:

Só para comparar,o mesmo exemplo em Haskell:

expo :: Int->Int->Int expo b e | e == 0 = 1 | e == 1 = b | otherwise = b * expo b(e-1)

Espero q ajude!

Só para comparar, o mesmo código em scheme:

(define
	(expo a e)
	(cond 
		((= 0 e) 1)
		((= 1 e) a)
		((* a (expo a (- e 1))))
	)
)

Vegetto,se vc tiver tempo,em 1 semana vc aprende(…),vc deve se lembrar para q vc precisará dele…a facilidade de se treinar Haskell é q dificilmente o código ficará “Grande” digamos assim…o seu trabalho maior eh pensar recursivamente,o q a maioria não está acostumada a fazer(Ateh pq não precisa…).

Ae louds,em scheme os operadores são pré-fixados?
Isso me faz lembrar as aulas de Estrutura de Dados I e Prolog…

“Ironlynx”:

Ae louds,em scheme os operadores são pré-fixados?
Isso me faz lembrar as aulas de Estrutura de Dados I e Prolog…

Sim, por ser uma linguagem derivada do lisp você tem toneladas de parenteses e notação prefixada. A maravilha disso é que toda sintaxe da linguagem pode se explicada em 2 minutos, alguem conhece alguma outra linguagêm que te permite isso? hehehehe

Bom acho q Haskell não fica atrás em matéria de simplicidade,mas como usa e abusa de recursividade,não eh para todas as necessidades…
Desculpe a ignorância,o que eh lisp?O mais underground de programação q aprendi foi prolog e Haskell mesmo!

Lisp é uma linguagem funcional baseada em listas…
O auto cad por exemplo, vc pode usar o auto lisp, que é uma variação do mesmo (isso, se não me falha a memória)

É uma linguagem muito legal, onde vc pode fazer umas coisas muito loucas, um exemplo disso é passar uma função como parâmetro de outra… :shock:

Além disso, ela é muito boa para trabalhar com recursividade…

Até os operadores matemáticos são funções, por exemplo para somar 6 números é mais ou menos isso:
(+ 1 2 3 4 5 6)

Legal né!!!
Existe ainda o scheme, que é uma variação muito usada em faculdades (não lembro se americanas ou européias) para os cursos de informática e o common Lisp que é usado mais profissionalmente!!!

Uma definição de fatorial seria mais ou menos o seguinte:

(defun fatorial (x)
     (if (equal x 1)
         1
         (* x (fatorial (- x 1))))

E por ai vai!!!
Vou ver se acho um link de um livro em pdf sobre lisp que eu devo ter em algum lugar!!!

Fallow

Scheme é a versão para meros mortais de lisp. LISP é a precursora das linguagens funcionais, que por sua vez são baseadas no principio do cálculo lambda, que data da mesma época da máquina do Alan Turing.
A principal diferença entre linguagens funcionais e imperativas é fato de código e dados serem a mesma coisa no primeiro caso.

Põe off nisso,mas já viu onde Java se encaixa entre as imperativas e funcionais…?Em nenhuma!Eh engraçado,mas ela eh considerada out-off da lista pq eh considerada mais do q linguagem!Tecnologia JAVA.Muitos relutam ateh em chama-lá de linguagem OO(como c++).Seria Tecnologia Orientada a Objetos?Java rulezzzzz

Ironlynx, vira esses pom-pons pra lá! De aspirante a cheer-leader aqui já basta o pessoal que baba em qualquer coisa que sai pra Eclipse :lol:

Bom, voltando ao assunto, a linguagem Java não é funcional. Os requisitos para uma linguagem ser funcional, se não me engano, são:

• Funções como tipos primários (não primitivos, primários!)
• Funções anônimas (lambda)
• Tipos como tuplas, listas e mapas suportados diretamente na linguagem (no caso do LISP, listas ja sao mais do que suficientes… Python tem os 3)
• Closures
• Ausência, ou pouca necessidade de usar iteração

Algumas linguagens funcionais, e algumas nem tanto, mas que pode-se discutir:

• LISP
• Haskell
• Scheme
• Erlang

“Nem tanto”, por não ter closures, ou não ter funções anônimas:

• Python
• Ruby
• XSLT

Com certeza tem mais, esses são só alguns exemplos

Cv,dos aspectos principais só esqueceste do uso FORTE da recursão como substituto da ITERAÇÂO(Falo por Haskell,q eh a q eu sei… ).
Bom qto ao Java…no words(…).Mas que ela escapou do campo de linguagem de programação escapou(tô falando sem sectarismo)… já tô ouvindo a “lenda” até q a Macromidia reformulou o Flash(Com a nova especificação ActionScript 2.0),para q ficasse mais claro a api para programadores substituirem front-end Swing p/Flash…se é verdade ou não eu não sei,mas bem q ela tah olhando com carinho pra comunidade JCP tah…

Cv
Para os puristas de linguagens funcionais, acredite ou não, list/scheme não são linguagens verdadeiramente funcionais! Isso se da ao fato que em uma linguagem puramente funcional, como ML, você não altera o valor vinculado a um nome depois de declarado.

Existem dois outros recursos muito legais que eu gosto de linguagens funcionais: lazy evaluation e continuations.

Aos especialistas em LISP…

Porque consigo calcular o fatorial de 10000 com a função que o TedLoprao citou??? Como o LISP trata as operações matemáticas???

Bom como Haskell tb eh uma linguagem derivada de Lisp(pelo q li) isso acontece porque o tipo inteiro(Integer) é INFINITO.Não há estouro…só por limitações da sua máquina.Pegue uma sequencia de fibonnacci em Haskell por exemplo:

fib:: Integer->Integer fib 0=0 fib 1=1 fib (n+2)=fib(n+1)+fib n

Se vc botar para rodar fib 50 por exemplo,funcionará perfeitamente…
Mas demora um eternidade…
Detalhes:
http://www.haskell.org/aboutHaskell.html

Realmente, ele só não irá calcular quando faltar recursos de máquina (ao menos foi o que percebi nos meus testes, hehehe)… Entretanto, se vc chegar ao topo do fatorial que postei, tente fazer um sem utilizar recursividade que vc perceberá que ele pode chegar mais além (essa eu tbm testei )

Fallow