Aprendendo recursividade

Programação Java
#21

[quote=wellington.nogueira]Cara,

Tenho a linha resolvida aqui. Só não postei pq o interesse é que você aprenda. Se teoricamente, você entendeu, não deve ser difícil resolver.
Como disse, montei a estrutura, é só trocar os bloquinhos. Teu único “problema” é onde vai ficar o Sysout. MAs isso te ajudo a resolver depois que você montar a linha do ternário.

if(b>500){ //CONDICAO return 0; //RESULTADO_CASO_CONDICAO_VERDADEIRO }else{ System.out.println(a); //tire isso daqui. return calculaFibonacci(b, a+b); //RESULTADO_CASO_CONDICAO_FALSO } //Coloque o return antes do ternário (não pode haver o return entre os sinais [b]?:;[/b])

Ternário é um pouco estranho mesmo, mas uma vez compreendido, fica muito simples ;)[/quote]

Brother o ternário que eu quero montar é assim:

return (b>500) ? 0 : System.out.println(a) E CHAMA calculaFibonacci(b, a+b);
escrevi misturando codigo com figuração mas é isso: na condição VERDADEIRO quero que ele execute IMPRIME A e ainda CHAME calculaFibonacci(b, a+b); (duas orientações pra condição FALSO !! pode ?)
Outra coisa: E se dentro da condição eu quisesse nao só testar o B mas o A tb, poderia ?
valeu

#22

[quote=wellington.nogueira]Ternário é uma forma de atribuir um valor ou outro conforme uma determinada regra.

Ou seja, é para um uso muito específico.
Exemplo: int variavel = 0; if(condicao) { variavel = 1; } else { variavel = 2; }
Neste exemplo, variavel é inicializada com zero. De acordo com uma condição específica, se a mesma for verdadeira, é atribuido 1; se for falsa, é atribuído 2.
Neste contexto, podemos alterar para um ternário ( o operador ternário é representado por ?: )
Exemplo convertido:

int variavel = 0; variavel = condicao ? 1 : 2; ou int variavel = condicao ? 1 : 2; //A inicialização foi suprimida, neste exemplo é desnecessário.

O valor que fica entre ? e : deve ser do mesmo tipo que o que fica entre : e ;.

Não é permitida mais que uma instrução em cada parte do ternário, ou seja, o exemplo abaixo não é permitido.

int variavel = condicao ? System.out.println("Valor"); 1 : 2;

[/quote]
Pois é, aqui tu responde para da minha questao: “Não é permitida mais que uma instrução em cada parte do ternário”
Entao como proceder pra gerar a serie fibonacci recursivamente e usando o op ternario em apenas uma linha …humm…bom desafio…

#23

Cara, o Wellington mastigou tudo pra você, não precisa nem pensar em nada é só pegar o código acima completar as lacunas no código abaixo:

return CONDICAO ? RESULTADO_CASO_CONDICAO_VERDADEIRO : RESULTADO_CASO_CONDICAO_FALSO ;

E eu tenho a apostila da Caelum também… É sim, um desafio, mas se você quer fazer em uma linha você não conseguirá imprimir!
E é um desafio estranho, porque qualquer programador que veja um código desses em uma linha já chutaria a canela de quem fez isso! Dar manutenção em código bruxo é fogo!

#24

[quote=wellington.nogueira][quote=fernandosavio]Cara, o Wellington mastigou tudo pra você, não precisa nem pensar em nada é só pegar o código acima completar as lacunas no código abaixo:

return CONDICAO ? RESULTADO_CASO_CONDICAO_VERDADEIRO : RESULTADO_CASO_CONDICAO_FALSO ;

E eu tenho a apostila da Caelum também… É sim, um desafio, mas se você quer fazer em uma linha você não conseguirá imprimir!
E é um desafio estranho, porque qualquer programador que veja um código desses em uma linha já chutaria a canela de quem fez isso! Dar manutenção em código bruxo é fogo!
[/quote]Consegue imprimir sim :wink:
Existem malícias no ternário que só Beelzebuth pra agradecer :twisted:
Essa desse exercício é simples. Fica, inclusive, elegante hehe.

Só pra exemplificar HellCode, veja esse: I Love Ternary[/quote]

Cosengue imprimir sim? puxa cara nem sem imprimir eu consegui montar isso tudo com o op ternario em apenas uma linha e gerar a serie fibonacci. Podes mostrar ai?
thank’s

#25

[quote=fernandosavio][quote=wellington.nogueira]

if(b>500){ //CONDICAO return 0; //RESULTADO_CASO_CONDICAO_VERDADEIRO }else{ System.out.println(a); //tire isso daqui. return calculaFibonacci(b, a+b); //RESULTADO_CASO_CONDICAO_FALSO } //Coloque o return antes do ternário (não pode haver o return entre os sinais [b]?:;[/b])

[/quote]

Cara, o Wellington mastigou tudo pra você, não precisa nem pensar em nada é só pegar o código acima completar as lacunas no código abaixo:

return CONDICAO ? RESULTADO_CASO_CONDICAO_VERDADEIRO : RESULTADO_CASO_CONDICAO_FALSO ;

E eu tenho a apostila da Caelum também… É sim, um desafio, mas se você quer fazer em uma linha você não conseguirá imprimir!
E é um desafio estranho, porque qualquer programador que veja um código desses em uma linha já chutaria a canela de quem fez isso! Dar manutenção em código bruxo é fogo!
[/quote]
eu penso que terei de ser algo mais ou menos assim:

class Fibonacci {
	int calcula(int a, int b){
		return (b>500) ? 0 : System.out.println(a) DAI CHAMA calcula(b, a+b);	
	}
}

mas foi me dito que nao pode duas instrições nem no TRUE nem no FALSE.

#26

Assim dá pra fazer uma classe toda em uma linha!
eauheuhaheuuahe

#27

[quote=wellington.nogueira]Cara,

Tenho a linha resolvida aqui. Só não postei pq o interesse é que você aprenda. Se teoricamente, você entendeu, não deve ser difícil resolver.
Como disse, montei a estrutura, é só trocar os bloquinhos. Teu único “problema” é onde vai ficar o Sysout. MAs isso te ajudo a resolver depois que você montar a linha do ternário.

if(b>500){ //CONDICAO return 0; //RESULTADO_CASO_CONDICAO_VERDADEIRO }else{ System.out.println(a); //tire isso daqui. return calculaFibonacci(b, a+b); //RESULTADO_CASO_CONDICAO_FALSO } //Coloque o return antes do ternário (não pode haver o return entre os sinais [b]?:;[/b])

Ternário é um pouco estranho mesmo, mas uma vez compreendido, fica muito simples ;)[/quote]

ok Brother!
Peguei a tua logica (pq a minha nao funfa com ternario devido a ter mais de uma instrução) e montei o ternario, mas eu confesso que com a tua lógica ficou muito facil construir o ternario.
Tenho a impressão q eu tava quebrando a cabeça em cima do ternario mas o problema é que nunca ia dar mesmo pq eu tinha que mudar pra uma lojica mais sucinta pra poder ser aceita na sintaxe do ternario.

[code]class Fibonacci {
int calcula(int a, int b){
return (b > 500) ? 0 : calcula(b, a+b);
}
}

[code]class GeraSerie {
public static void main(String[] args){

	Fibonacci fibo = new Fibonacci();
	
	int i = fibo.calcula(0, 1);
	System.out.print(i);	
}

}[/code]

tinha que te me esforçado mais pra sair da minha lógica (duas instruções pra procesar):
a = a + b
b = b + a
e descobrir a tua(uma instrução apenas):
(b, b + b)

Assim compilou e rodou ok (claro: Permanece o problema de “como vai imprimir” sem ferir o que o exercicio pede que é “recursividade+ternario+1 linha só”)

to até fazendo teste de mesa aqui pra entender essa logica passo a passo pq nao saquei legal ainda.

#28

Na verdade Welingtom eu nao achei ternario estranho mas o que complicou mesmo é que eu queria algo impossivel: dar mais de uma instrução pra FALSE e mais de uma pra TRUE
abração

#29

puxa vida!!!
agora que descobri que a logica q eu usava funfa com ternario se eu botar ela dentro do parenteses da re-chamada da função calcula()

class Fibonacci {
	int calcula(int a, int b){
		return (b > 500) ? 0 : calcula(a=a+b, b=b+a);	
	}
}

4 dias pra sacar isso …ufsssss… eta curva de aprendizam longa essa do java (tinha que ser JAVEX tao rapido de aprender qto enviar carta pelo SEDEX)
rssss
mas valeu , instigou pra caramba e dai fixei hehhe

#30

[quote=wellington.nogueira][quote=rafaelczy]…
eu penso que terei de ser algo mais ou menos assim:

class Fibonacci {
	int calcula(int a, int b){
		return (b>500) ? 0 : System.out.println(a) DAI CHAMA calcula(b, a+b);	
	}
}

mas foi me dito que nao pode duas instrições nem no TRUE nem no FALSE. [/quote]
Sim, não pode mesmo. A idéia é quase essa. Tire o System.out.println(a) colocando-o na linha de cima primeiro.

int calcula(int a, int b){ System.out.println(a); return (b>500) ? 0 : calcula(b, a+b); }

Se quiser uma linha, alinhe os comandos e pronto, está tudo numa linha.

		System.out.println(a); return (b>500) ? 0 : calcula(b, a+b);

[/quote]

Baita pega ratao da apostila - me cravei todo pq achava q o exercicio queria tudo numa linha sem essa de “;” pra disfarçar. Como foi dito “Assim da pra construir uma classe inteira e uma linha”

#31

detalhe, essa logica nao gera a serie

int calcula(int a, int b){ System.out.println(a); return (b>500) ? 0 : calcula(b, a+b); }

essa gera ok:

class Fibonacci { int calcula(int a, int b){ System.out.print(a + "" + b); return (b > 500) ? 0 : calcula(a=a+b, b=b+a); } }

mas tua ajuda foi fundamental men!

#32

opssss…(conforme manda o exercicio)

class Fibonacci {
	int calcula(int a, int b){
		System.out.print(a + "" + b);return (b > 500) ? 0 : calcula(a=a+b, b=b+a);	
	}
}
#33

[code]public class fibonacci{

public static int fib(int i){
if (i==1 ||i==2)
return 1;
else
return (fib(i-1)+fib(i-2));
}
public static void main (String[] args){
fibonacci f = new fibonacci();
int n = Integer.parseInt((JOptionPane.showInputDialog(“Introduza a quantidade de elementos a serem imprimidos”));

for(int i = 0;i<n;i++){
System.out.println(f.fib(i));
}
[/code]

#34

[quote=wellington.nogueira][quote=fernandosavio]Assim dá pra fazer uma classe toda em uma linha!
eauheuhaheuuahe[/quote]
É que, na minha opinião, a impressão do resultado não está inclusa nessa história de colocar numa linha só ;)[/quote]
Concordo plenamente!
Foi o que pensei desde o início. Pois imprimir o resultado não faz parte da Sequencia de Fibonacci!
O que eu pensei foi isso:

public class MainTeste {

	public static void main(String args[]){
		System.out.println(fibonacci(8, 0, 1));

	}
	public static int fibonacci(int limite, int a, int b){                 //Limite=enésimo elemento da sequência
		return (limite>1) ? fibonacci(limite-1, b, a+b) : a ;
	}
}

Aí retorna só o número que realmente se precisa saber

#35

Bom galera, jamais pensei q iria encher 3 paginas de posts pra gerar esse fibonacci de todas formas pedidas (num de var livre, depois 2 var apenas, depois recursividade, depois ternario + recursividade + 1 linha só) ufsss… 7 dias morando no forum…
mas valeu
fixei legal recursividade e op ternario
parabens ai pros atores principais da comedia q ajudaram e determinaram o sucesso
Welligton nogueira e Fernando savio
a todos demais thank’s to!

After thousands of years in caelum apostila charpeter 4 finaly going to the charpter 5 :shock:

#36

Eu já conhecia recursividade e operadores ternário mas também foi um aprendizado…
Não precisa agradecer, qualquer coisa mais que precisar e eu souber estamo aí!

#37

Mais uma questão galera:
A apostila da caelum fala no fim do cap.4 qdo pede pra gerar a serie fibonacci usando recursividade, que essa tecnica é mais demorada em materia de processamento que um laço comum.
Por que pessoal ?
achei interessante a questão!

#38

A recursividade é mais custosa em termos de processamento. Pois o Sistema Operacional aloca espaço para uma função Fibonacci e ela chama ela mesmo, então essa primeira instância fica na memória e o sistema operacional empilha outra instância do método na memória, e aí ele chama ele de novo e cria outra instância… e por aí vai! A última instância retornará a resposta requisitada e retornará para a instância que a chamou até chegar na primeira instância do método que retornará para o usuário a resposta desejada…
Resumo: O SO empilha os métodos recursivos até que algum deles retorne e desempilha tudo.
Então a recursividade gasta mais porque cria várias instâncias do mesmo método até que ele se resolva.

Espero não ter complicado muito!

#39

[quote=fernandosavio]A recursividade é mais custosa em termos de processamento. Pois o Sistema Operacional aloca espaço para uma função Fibonacci e ela chama ela mesmo, então essa primeira instância fica na memória e o sistema operacional empilha outra instância do método na memória, e aí ele chama ele de novo e cria outra instância… e por aí vai! A última instância retornará a resposta requisitada e retornará para a instância que a chamou até chegar na primeira instância do método que retornará para o usuário a resposta desejada…
Resumo: O SO empilha os métodos recursivos até que algum deles retorne e desempilha tudo.
Então a recursividade gasta mais porque cria várias instâncias do mesmo método até que ele se resolva.

Espero não ter complicado muito![/quote]

Logo, se eu desejo criar uma aplicação leve e rápida pra uma plataforma com pouca mem RAM e pouca vel de processador, o negócio é evitar recursividade. certo?

#40

[quote=rafaelczy][quote=fernandosavio]A recursividade é mais custosa em termos de processamento. Pois o Sistema Operacional aloca espaço para uma função Fibonacci e ela chama ela mesmo, então essa primeira instância fica na memória e o sistema operacional empilha outra instância do método na memória, e aí ele chama ele de novo e cria outra instância… e por aí vai! A última instância retornará a resposta requisitada e retornará para a instância que a chamou até chegar na primeira instância do método que retornará para o usuário a resposta desejada…
Resumo: O SO empilha os métodos recursivos até que algum deles retorne e desempilha tudo.
Então a recursividade gasta mais porque cria várias instâncias do mesmo método até que ele se resolva.

Espero não ter complicado muito![/quote]

Logo, se eu desejo criar uma aplicação leve e rápida pra uma plataforma com pouca mem RAM e pouca vel de processador, o negócio é evitar recursividade. certo?[/quote]

Exato ! :thumbup: