Vlw pela dica…Vou ver direitinho
[quote=samanta.santos][color=red]Bom dia, alguém pode me ajudar a fazer esse exercício?[/color]
[color=red]Imprima os fatoriais
O fatorial de um número n é n * n-1 * n-2 … até n = 1. Lembre-se de utilizar os parênteses. O fatorial de 0 é
1 O fatorial de 1 é (0!) * 1 = 1 O fatorial de 2 é (1!) * 2 = 2 O fatorial de 3 é (2!) * 3 = 6 O fatorial de 4 é (3!) *
4 = 24[/color][/quote]
Vamos pelo começo:
Uma função é um conceito matemático onde você passa uma ou mais elementos para ela, números normalmente, e ela te retorna um resultado, uma para cada entrada diferente que você colocar.
Exemplo
A função F recebe um x, e te retorna um y. F(x) = y. O corpo da função F é x². Então F recebe um número x, e te retorna o quadrado dele. Isto em Java seria:
public double F (double x)
{
double y = x * x;
return y;
}Aí cabe uma decontrução de coisas de linguagens de programação, como o Java. Java é uma linguagem que dizemos que tem uma tipagem estática e forte, e isto quer dizer que você define o tipo das variáveis, e o tipo de retorno de funções. No exemplo acima:
public: é um modificador de acesso da função, quer dizer que qualquer classe de fora pode acessar este método da classe.
double F: double é o tipo de retorno, que são números reais (também conhecidos como números de ponto flutuante), e F é o nome da função.
(double x): dentro do parênteses fica a declaração dos parâmetros da função, que usamos para mandar os números e outros objetos para dentro da função quando o chamamos.
{}: Entre chaves fica o corpo da função, onde se implemente o que ele faz, através de vários comandos.
double y: é uma variável de nome y com o tipo double.
return: usamos para apontar que número da função irá retornar. Depois que e dado o return, a função acaba imediatamente.
Uma observação, em Java, cada linha de comando/expressão que você usar, tem que terminar ela com ; (ponto-e-vírgula).
Outro método:
public void imprimir(double numero)
{
System.out.println(numero);
}De novo temos aqui é que este método não retorna nada. Para métodos que não retornam valores nós colocamos o tipo void para ele, que significa vazio. Dentro do corpo do método também não tem nenhum return, já que ele não retorna nada mesmo. O tipo void só pode user usado para métodos, variáveis sempre tem um tipo que não é vazio.
Para os dois métodos acima, os chamamos desta forma:
public void calcular()
{
double a = F(1);
double b = F(2);
double c = F(3);
imprimir(a); //imprime 1.0
imprimir(b); //imprime 4.0
imprimir(c); //imprime 9.0
}Outra modalidade de funções que existem são umas que chamam elas mesmas dentro do código. Como esta:
public double G(double numero)
{
double x = 1 + G(numero);
return x;
}Esta funcão calcula o valor dela mesma + 1. Um problema grave de funções recursivas é que elas acabam chamando elas mesmas, que chamam elas mesmas, que chamam elas mesmas, que chamam elas mesmas, sem fim. Isto vai acabar estourando a memória destinada para executar estas funções pois não tem fim. A solução é colocar um fim nelas. É o que chamamos o ponto de parada.
public double G(double numero)
{
if (numero <= 0)
return 0;
double x = 1 + G(numero - 1);
return x;
}A modificação que fiz acima é para quando passarmos um número menor ou igual a zero, a função irá retornar um zero. Outra modificação é ir diminuindo o número repassado, para que ele chegue de poucos em poucos até a condição de parada. Se chamarmos o número 2, a função vai chamar ela mesma com o número 1, que por sua vez, irá passar um 0, e aí sim irá retornar um número de verdade. Retornando 0 para cima, a função soma este 0 com 1, e retorna 1. A função acima recebe este 1, soma com mais 1, e retorna 2. Retornando este 2, a função acaba, sem mais recursões, e volta para o programa que chamou a função originalmente.
Desta forma finalmente chegamos ao fatorial:
Então
0! é 1
1! é 0! * 1
2! é 1! * 2
3! é 2! * 3
4! é 3! * 4
A condição de parada é que quando cheguemos a zero, ele retorne 1. Então
if (numero == 0)
return 1;A continuação acontece para qualquer outro número maior que zero, onde fazemos que o fatorial de um número é o fatorial do número menos um, vezes o próprio número
else
return fatorial (numero - 1) * numero;Juntando tudo:
public int fatorial(int numero) // o fatorial de um número
{
if (numero == 0)
return 1; // é 1 caso o número seja 0
else
return fatorial (numero - 1) * numero; // é fatorial(n-1)*n caso contrario
}Só um aviso, só existem fatoriais de números naturais, ou seja, inteiros e positivos. Não passe um número menor que zero, ou outro número real.
Também podem ocorrer problemas se tentar fatoriais de números muito grandes, o integer do Java tem um limite de tamanho até o número 2.147.483.647.
Também há maneiras de resolver isto sem recursão.
Programa final:
public class Programa
{
public static void main(String[] args)
{
Programa p = new Programa();
int fatorialDe10 = p.fatorial(10);
System.out.println(fatorialDe10); // imprime 3628800
}
public int fatorial(int numero) // o fatorial de um número
{
if (numero == 0)
return 1; // é 1 caso o número seja 0
else
return fatorial (numero - 1) * numero; // é fatorial(n-1)*n caso contrario
}
}[quote=maior_abandonado]depois dessa vo criar um usuario com nome de mulher e pegar uma foto qualquer no google para sempre que precisar de alguma coisa no forum… :x
caramba passam assim exercicio de mão bejada desse jeito…por isso que sempre tem uns folgados vindo pedir para resolvermos os exercicios da faculdade deles…sempre tem quem faça mesmo…[/quote]
++
Ola, infelizmente seu codigo esta muito errado, vou colocar aqui alguns erros que eu vejo de primeira vista:
if (j <=1) return 1
else
return fat = j*fat(j-1);
System.out.println("O fatorial deste numero e: " +fat); Isto acima vai gerar um erro de compilação já que vc ou no if ou no else vai sair da função usando a palavra reservada return, logo este ultimo System.out.println nunca vai ser chamado.
int i, j, fat = 1;
return fat = j*fat(j-1); Aqui seu codigo faz pouco sentido, primeiro vc declara a variavel fat como um int, depois vc tenta utilizar a mesma como uma função, atribuindo o resultado a ela mesma.
fat(j-1);O que vc deve fazer, é criar um outro método, fora do main, chamado fat, que faça esta chamada recurciva algo assim:
public static void main(String []args) {
//instancia a classe
System.out.println(classeInstanciada.fat(5));
}
public double fat(double value) {
//aqui vai ter aquele seu if (j <= 1) e a chamada recursiva da função (j*fat(j-1);)
}Espero ter ajudado a clarear a sua mente.