Jump to content

Recursividade


alphasil

Recommended Posts

para a funcao ser recursiva tens que chamar essa funcao dentro da mesma

Por muito mais que que estude só aprendo uma coisa, que ainda tenho muita coisa para aprender.

A beleza de um código está em decompor problemas complexos em pequenos blocos simples.

"learn how to do it manually first, then use the wizzy tool to save time."

"Kill the baby, don't be afraid of starting all over again. Fail soon, learn fast."

Link to comment
Share on other sites

repara no numero de parenteses abertos e fechados

return (2*valor+3(valor-1)

depois tens de verificar o que o @pikax te constatou :

para a funcao ser recursiva tens que chamar essa funcao dentro da mesma

no entanto na tua declaração, a função "soma(2*i+3)" não tem esse conceito associado.

isso para mim é somente (caso i = 1) 2*1+3 = 5;

quererás dizer queres o somatório de 2*i+3, para i=0 até n ??

nesse caso, sim, tens a tua recursividade (n=4):

resultado = (2*0+3) + (2*1+3) + (2*2+3) + (2*3+3) + (2*4+3)

ou para simplificar:

resultado = (2*4+3) + (2*3+3) + (2*2+3) + (2*1+3) + (2*0+3)

(a mudança da ordem é para perceberes como o valor do "i" muda na recursividade)

IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

Oi;

Sim é recursividade que pede, calcula e retorna o valor do somatório apresentado recorrendo ao uso da recursividade.

Então o meu i vai ser o meu n?

*O parêntesis em falta foi falha ao passar visto que o tenho no código. 🙂

Estava a ver na documentação e vi algo parecido com isto:

return( num * num + sumatorio( num –1 );

Claro que aqui é a multiplicação do i*i mas estava a tentar adaptar a minha mas sem sucesso.

gmc11

 

Link to comment
Share on other sites

teres esse código seria aplicar o seguinte somatório

(vou usar e grande para sinalizar o somatório por parecer com o simbolo matemático do somatório)

E = i*i

isto porque o resultado seria (para n = 4)

4*4 + 3*3 + 2*2 + 1*1

agora faz a extrapolação para o teu caso

PS : no exemplo continua a faltar o fecho do parêntesis

Edited by HappyHippyHippo
IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

para perceberes o que tens segue o código

vamos supor que chamar a função recurs com os seguintes parâmetros: (2, 4)

(como não percebo a existência do parâmetro "num1", assim como nunca é usado, vou simplesmente ignorá-lo)

vou encadear o código que tens para tentares perceber o que se está a passar

// chamada da função
// isto implica a inicialização da variável [i]valor[/i]
// que vou chamar de [i]valor1[/i] porque é a primeira chamada da funcoo
// vai ser atribuido o valor de 2 porque assim foi suposto no exemplo
int valor1 = 2;

// verificas se o valor da variável [i]valor1[/i] é 0
if (valor1 == 0)
 return 0;

// como não é continuas

// agora, olhando para a formula matemática que tens
// vou alterar as ocorrências da variável [i]valor1[/i] pelo seu valor númerico
return (2*2+3*(2-1));
// se fizeres as contas isto vai-se simplificando desta forma
//   return 2*2 + 3*1;
//   return   4 +   3;
//   return         7;

como podes ver, o computador fez a conta bem ...

no entanto, não tem nada haver com o que te foi explicado de como o resultado deveria ser assim como não tens nenhuma recursividade no código ...

IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

epá eu não percebo é este atirar de hipóteses a ver se cola ...

tens um post teu de uma documentação que não faço ideia qual, que estás a seguir (que só posso presumir que te está à frente) com tem estes contornos

Estava a ver na documentação e vi algo parecido com isto:

return( num * num + sumatorio( num –1 );

(nem corrigi a falta do fecho dos parênteses)

eu expliquei o resultado deste tipo de operação no post seguinte:

isto porque o resultado seria (para n = 4)

4*4 + 3*3 + 2*2 + 1*1

tirando o pormenor da condição de paragem da recursividade (que por acaso tens bem !!!), fazer mais do que isto é pegar na mão, e fazer o execício por ti !!!

PS : depois veem dizer que me passo quando este tipo de situações decorrem constantemente ...

mas prontos, vou desenvolver melhor a explicação do código

int sumatorio(num) {
 if (num = 0)
   return 0;

 return( num * num + sumatorio( num – 1 ));
}

se chamares a função com n=4, isto é a mesma coisa que teres

4*4 + sumatorio(4-1);
// que é igual a
4*4 + (3*3 + sumatorio(3-1));
// que é igual a
4*4 + (3*3 + (2*2 + sumatorio(2-1)));
// que é igual a
4*4 + (3*3 + (2*2 + (1*1 + sumatorio(1-1))));
// que é igual a
4*4 + (3*3 + (2*2 + (1*1 + 0))))
// que é igual a
4*4 + 3*3 + 2*2 + 1*1

agora é só aplicares ao pretendido:

nesse caso, sim, tens a tua recursividade (n=4):

resultado = (2*0+3) + (2*1+3) + (2*2+3) + (2*3+3) + (2*4+3)

ou para simplificar:

resultado = (2*4+3) + (2*3+3) + (2*2+3) + (2*1+3) + (2*0+3)

(a mudança da ordem é para perceberes como o valor do "i" muda na recursividade)

Edited by HappyHippyHippo
IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.