Recursividade

[alphasil]

Oi ppl;

Estou a tentar resolver um problema que me diz o seguinte:

n

soma(2*i+3)

i=1

Tenho algo assim

int recurs(int valor)
{
if(valor==0)
{
return 0;
}
else
{
return (2*valor+3(valor-1)
}
}

Isto está correto??

Obrigado

[pikax]

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

[HappyHippyHippo]

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)

[alphasil]

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.

[HappyHippyHippo]

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 July 6, 2012 at 09:26 AM by HappyHippyHippo

[alphasil]

Está certo assim:

int recurs(int valor, int num1)
{
   if(valor==0)
   {
    return -1;
   }
   else
   {
    return(2*valor+3*(valor-1));
   }
   return 0;
}

assim dá-me

para i=1 = 2

para i=2 = 7

??

[Flinger]

Então pensar lá no que tens e no que queres...

Queres (para i =4) : (2*4+3) + (2*3+3) + (2*2+3) + (2*1+3).

O que tu tens, segundo a tua função é: 2*valor+3*(valor-1) ou seja : 2*4+3*3.

Conselho... (2*4+3) tenta obter isto (para i=4). Depois o que te falta?

[HappyHippyHippo]

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 ...

[alphasil]

falta o i-1

Para baixar 1 até ao 0.

certo?

Seguindo as vossas indicações, tenho de chamar novamente a função e usar o i-1

recurs e depois o 2*valor(valor-1) +3?

Edited July 6, 2012 at 10:11 AM by alphasil

[HappyHippyHippo]

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 July 6, 2012 at 10:22 AM by HappyHippyHippo

[alphasil]

Oi

pus assim, os valores parecem dar certo,

return((2*num+3)+recurs(num -1));

Ou seja, é feita o calculo de 2.num+3 e é chamada a função que usa num-1 até o critério de paragem.

é isso???

[Flinger]

Exacto

[HappyHippyHippo]

vês como tinhas a explicação de como fazer em todos os posts anteriores !?!?

basta ler com atenção ...

[alphasil]

Obrigado ppl;

HHH, mais uma vez obrigado pela tua paciência, tens razão mas o que as vezes é óbvio para ti, não o é para os outros mas louvo o teu empenho em ajudar toda a gente, parabéns e muito obrigado.

cumps