Faça um programa que leia um número N, maior que 0, e imprima o fatorial do número
lido.
No caso eu digitei o numero 5,quando foi solicitado para mim…e o resultado deu certo 120…mais quando eu digito outros numeros aparece 120 sempre…
import javax.swing.*;
public class Fatorial {
public static void main(String[] args) {
int n,fatorial=1,cont;
n=Integer.parseInt(JOptionPane.showInputDialog("digite o numero"));
for (cont=1;cont<=n;cont++){
cont++;
fatorial=cont++*cont++*cont++*cont;
}
System.out.println ("o fatorial "+fatorial);
}
}
public static void main(String[] args) {
int n,fatorial=1,cont;
n=Integer.parseInt(JOptionPane.showInputDialog("digite o numero"));
for (cont=1;cont<=n;cont++){
fatorial=fatorial*cont;
}
System.out.println ("o fatorial "+fatorial);
}
}[/code]
o seu codigo da errado pq sempre vc vai estar multiplicando o cont e não está acumulando o valor fatorial do numero.
a lógida de dentro do seu loop está errada, tente fazer do jeito que o joede.fadel disse.
Alternativamente, vc pode tentar calcular o fatorial recursivamente.
Ei tíu, faça com BigInteger pra não dar estouro de dados no seu programa, e se o alguem derrepente digitar 5555???
Seu computador vai explodir hahaha.
Eu tentei fazer o seu programa com BigInteger, vÊ se funciona:
// Programa que calcula o fatorial de um número
package fatorial;
import javax.swing.JOptionPane;
import java.math.BigInteger;
public class Fatorial
{
public static void main(String[] args)
{
String num=JOptionPane.showInputDialog("Digite um número");
int n=Integer.parseInt(num);
int i;
BigInteger fatorial=new BigInteger("1");
BigInteger multiplicador=new BigInteger("1");
BigInteger mais1=new BigInteger("1");
for(i=1;i<=n;i++)
{
fatorial=fatorial.multiply(multiplicador);
multiplicador=multiplicador.add(mais1);
}
JOptionPane.showMessageDialog(null,"O Fatorial de "+n+" é:\n"+fatorial,
"FATORIAL",JOptionPane.PLAIN_MESSAGE);
}
}
Vê se a bagaça funciona que eu não testei, se o seu computador explodir, eu não sei de nada em.
mrcastro, não há problema nenhum de lógica com o programa do joede.fadel
Funciona bem. O único problema é que ele declarou a variável fatorial como sendo int. E isso faz com que haja um estouro na memória para números altos, até o 16 funciona bem, mas tente com o 17, dará um número negativo. Iso por que o tipo inteiro não comporta a faixa de valores para o fatorial de números acima de 17.
para resolver esse problema basta declarar a variável fatorial como double.
Essa tem que ir pro tápico que tá bombando, das frases de gerente de projetos
while é for é mais elegante que isso ?
inteiro Fibonacci (inteiro k)
{
se k = 1: devolvo 1;
se k = 2: devolvo 1;
devolvo Fibonacci(k - 1) + Fibonacci (k - 2);
}
A recursividade é a forma mais fácil de se implementar uma sequência,
no entanto a menos eficiente dependendo do tamanho da lista
Mas se tiver disponível muita memória não tem problema
então pode usar a memoização para conseguir uma maior eficiência com a implementação mais simples.
só Phiton faz isso java da pra fazer com HashMap
A reiteração é a forma aberta da recursividade e o algoritmo que os programadores buscam,
muitas vezes apenas porque desconhecem outras soluções.
A matriz característica é uma boa solução, se a potência de matrizes for implentada de forma binária
caso contrário se torna muito ineficiente.
De qualquer forma, é possível calcular a função fechada, que resolve a sequência por álgebra linear,
método altamente eficiente e que não sofre muita variação ao longo da projeção cartesiana.
em complexidade pensa assim
= (O(n-1)) + 1
= (O(n-2) + 1) + 1
= O(n-2) + 2
= (O(n-3) + 1) + 2
= O(n-3) + 3
…
forma geral, O(n) = O(n-k) + k, 1 k n
Como k é o número do fatorial, fazendo n = k, reduzimos a O(n) = n
[quote=Focão]no entanto a menos eficiente dependendo do tamanho da lista
Mas se tiver disponível muita memória não tem problema[/quote]
Pois é. O problema é que o tamanho da lista nem precisa ser grande para o método recursivo falhar espetacularmente com um StackOverflow. Ninguém pensa em escalabilidade né? Só por que a complexidade do problema é linear, não quer dizer que todas as implementações são igualmente performáticas.
Se quiser mostrar o melhor, poste resultados como este:
