Bom dia,
Galera, Estou estudando pela apostila da Caelum e tem um exercício que é pra fazer uma conta fatorial de 1 à 10.
Eu fiz este exercício mas não se se está da maneira correta de fazer.
Mas os resultados em si, estão todos OK. (Conferir na calculadora 
).
class Exercicicio31{
public static void main(String []args){
// Exercio embaixo.
{
for(int n=1, fatorial=1; n <= 10; n++, fatorial = fatorial * n)
{
System.out.println("Fatorial de "+n + " é " + fatorial );
}
}
}
}Acredito que está correto sim (ainda mais se você conferiu na calculadora hehe).
Mas tem o detalhe de está não ser a forma mais indicada para programar. Usar todas as instruções dentro da expressão de repetição ( no caso um for) funciona, porém deixa o código bastante difícil de ler e interpretar. Sugiro que você separe estas instruções em linhas dentro do for (o que for possível separar) e, se achar interessante, adicione alguns comentários.
Não vou te entregar o código feito, pra não dar de graça também né?!
EDIT: Se tiver alguma dúvida depois do refactor do código, poste aí que verificamos.
David,
Tentei da uma arrumada.
Analisa por favor.
public class Exercicicio31{
public static void main(String []args){
// Exercio embaixo.
int n;
int fatorial;
for(n=1, fatorial=1; // valores
n <= 10; // Faz o laço.
n++, fatorial = fatorial * n) //Vou acrecentar sempre 1 em cima do valor do N e farei a contar do fator
{
System.out.println("Fatorial de "+n + " é " + fatorial ); // Imprimir mensagem na tela.
}
}
}Não era bem isso que eu estava pensando. Não sei se me expressei mal ou o que, mas vou tentar ser mais claro desta vez.
Vamos analisar a sintaxe e a semântica do comando for:
for(<inicialização> ; <condição> ; <expressão de iteração>){
// instruções a serem repetidas
}Agora vamos ver seu código:
for(n=1, fatorial=1; // valores
n <= 10; // Faz o laço.
n++, fatorial = fatorial * n) //Vou acrecentar sempre 1 em cima do valor do N e farei a contar do fator
{
System.out.println("Fatorial de "+n + " é " + fatorial ); // Imprimir mensagem na tela.
} Análogamente:
<inicialização> = n = 1, fatorial = 1 : Está ok, porém se as variáveis n e fatorial são usadas exclusivamente no for, elas poderiam ser declaradas aqui, evitando disperdício de memória caso houvessem mais linhas após o for.
<condição> = n <= 10 : Está ok, sem problema algum.
<expressão de iteração> = n++, fatorial = fatorial * n : Aqui que "mora o perigo", a instrução "n++" pode ser colocada aqui sem problema algum, já que ela que faz com que o loop "avance" e a variável n faz parte da condição de repetição. A instrução "fatorial = fatorial * n", porém, faz parte da solução do problema e não tem ligação com a condição da iteração (como se fizesse parte das tão faladas regras de negócio). Assim, o mais indicado é mover esta instrução para dentro do for (dentro do bloco), mais ou menos assim:
for (int n = 1, fatorial = 1; n <= 10; n++) {
fatorial = fatorial * n;
System.out.println("Fatorial de " + n + " é " + fatorial);
}Desta forma, ocorre a separação entre o que define a repetição e o que exatamente ela faz. Repare também que a declaração das variáves n e fatorial agora ocorre dentro do for.
Desculpe se estou sendo chato ou coisa assim. Minha intenção apenas é que você escreva códigos com mais clareza e legibilidade. Nesta situação de cálculo de fatorial, o programa é bastante simples e a iteração também, porém é bom que você se acostume com as boas práticas desde o princípio, para que no futuro não saia escrevendo iterações deste tipo:
for ( x = 0, y = valorMaximo, z = 0 ; (x + z) < y; x + z - ((obterValorAtual() - obterDiferencaAtual()) * obterMultiplicadorAtual()) ) {Este é um exagero, porém pode acontecer de uma iteração que seja clara para você pareça uma sopa de letrinhas para outro programador, ou para você mesmo quando precisar mexer na rotina que escreveu anos atrás.
Já que estamos falando em formatação de código, preste atenção também às chaves e à identação.
Seu código:
public class Exercicicio31{
public static void main(String []args){
// Exercio embaixo.
int n;
int fatorial;
for(n=1, fatorial=1; // valores
n <= 10; // Faz o laço.
n++, fatorial = fatorial * n) //Vou acrecentar sempre 1 em cima do valor do N e farei a contar do fator
{
System.out.println("Fatorial de "+n + " é " + fatorial ); // Imprimir mensagem na tela.
}
}
} O padrão Java:
public class Exercicicio31 {
public static void main(String[] args) {
// Exercio embaixo.
int n;
int fatorial;
for (n = 1, fatorial = 1; n <= 10; /*Faz o laço.*/ n++, fatorial = fatorial * n /*Vou acrecentar sempre 1 em cima do valor do N e farei a contar do fator*/) {
System.out.println("Fatorial de " + n + " é " + fatorial); // Imprimir mensagem na tela.
}
}
}Espero ter sido claro.
Dúvidas ou críticas, poste aí!
Obrigado David.
Eu Entendi todos os pontos citados.
Vou praticar mais e fazer novos exercícios, espero quem na proxima vez você me ajude deste jeito
Obrigado.
Opa, com certeza alguém do GUJ vai te ajudar nestes casos de dúvidas.
Só não podemos fazer o exercício inteiro né?! :lol:
Valeu!
Desculpem entrar de penetra aqui, mas não pude resistir a mostra a solução recursiva, que é linda :lol:
public class Fatorial {
public static void main(String[] args) {
System.out.println(fatorial(7));
}
public static int fatorial(int num){
if(num<2) return 1;
else return num * fatorial(num-1);
}
}Hehehe, foi mal, não resisti. Só peço que se isso for exercicio de alguém, por favor tentem entender antes de entregar, senão jamais me perdoarei hehehehe.
A solução usando recursão é realmente bem interessante. Pena que é mais pesada nas arquiteturas tradicionais…
Olá, você fez só o download da apostila da Caelum ou participou do curso FJ-11?
Abraços
Só fiz o download mesmo.
Abraços
Eu fiz o treinamento na Caelum, participei dos cursos FJ-11 e FJ-21.
Caso você continue praticando e tenha alguma dúvida, pode contar comigo para ajudá-lo.
Ajudo sem problemas, só não passo os exercícios mastigados, daí não tem a menor graça!
Abraços,
Maddo