[SOLUCIONADO] [Ayuda]Factorial suma dígitos

[sixtoex]

n ! significa n × ( n - 1) × ... × 3 × 2 × 1

Por ejemplo, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3.628.800,
y la suma de los dígitos en el número 10! es 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

Encuentra la suma de los dígitos en el número 100!
-----------------------------------------------------------------------------------------

El programa hace las multiplicaciones correctamente, de cualquier numero, el problema es en el divisor, me explico, antes pongo el código:

Código Java:

public class FactorialDigito {
 
    public static void main(String[] args) {
        
        double Resultado = 1;
        double divisor = 1;
        long Sumatorio = 0;
        
        
        for(int i =100 ; i >= 1;i--){
        
        if(divisor < Resultado){
            divisor = divisor * 10; 
        }
        Resultado = i * Resultado;  
        
        if(divisor > Resultado && i == 1){
            divisor = divisor / 10;
        }
        
        if(i == 1){
        for(int x = 0; x == 0;){
        Sumatorio = (long)(Resultado / divisor)%10+(Sumatorio);
        divisor = divisor / 10;
        
        if(divisor == 1){
            x = 1;
        }
        }
        
        }
      
        }
            
System.out.println(Sumatorio);
    }
 
}
 

A ver el problema esta en la variable DIVISOR, cuando pongo un numero chiquitito(como 20)hace bien los (*10) pero cuando es un numero muy grande como por ejemplo 100, entonces el Divisor cuando llega a una cantidad muuuuuy grande, "se vuelve loco" y lo que hace es que se vuelve negativo.

10 = me da 27, que esta bien
20 = me da 54, tambien bien
30 = me da 157,¿Aquí ya no se si esta bien? (Aqui tambien hace cosas raras y se convierte en 9999999999999999 y luego se pone de nuevo a 1.0000000000000007E39 o lo que sea...)

Nota: No me hagan el código porfavor, prefiero que me ayudes antes que me hagas el código, para mejorar, gracias.

Que rabia me da

Saludos y muchisimas gracias a los que pierda tiempo en mi

[sixtoex]

Tambien quiero aclarar una cosita:

Modifique esta línea:

Código Java:

for(int e = 0; e < 99;e++){
            if(divisor < Resultado){
                divisor = divisor * 10; 
            }
            
            
        }
 

Creo que asi ahora esta mejor, por que muchas veces la diferencia era de 2-3 ceros
Aunque sigue fallando en numeros altos como el 100

[Xerelo]

1.0000000000000007E39 es 1.0000000000000007*10^39

Cuando los números son muy grandes (o muy pequeños) se representan con notación científica.

Por otro lado, double tiene una precisión determinada, no puedes representar cualquier número con un double (ni decimal ni entero), cuando eso ocurre lo sustituye un valor cercano.

Cuando se quiere trabajar con números muy grandes o con gran precisión, como dinero o cálculos científicos, se usa BigDecimal y BigInteger, auqnue estos tampoco son perfectos.

http://www.javamex.com/tutorials/mat...gInteger.shtml

No he leído tu código, así que quizás tengas también errores en tu algoritmo.

[sixtoex]

Xerelo amigo

Cuando creo:

Código Java:

BigDecimal Resultado = new BigDecimal(1);
        BigDecimal divisor = new BigDecimal(1);
        BigDecimal sumatorio = new BigDecimal(0);
 

Me da error en las sentencias...
divisor > Resultado

yo se que para multiplicar,dividir,sumar,restar hay que utilizar:

Código Java:

BigDecimal prueba = Resultado.add(otraVariable);
 

Pero el tema es que no se puede comparar... ejemplo, esto daría error:

Código Java:

if(divisor > Resultado){
            divisor = divisor / 10;
        }
 

Por lo menos se que lo hice bien por que hasta el 21, es capaz de hacerlo perfectamente, a partir del 22 es cuando da error...

Creo que este ejercicio la unica forma era haciendolo con métodos no?

[Profesor_Falken]

Buenas,

Para eso BigInteger tiene el método compareTo: http://www.tutorialspoint.com/java/m..._compareto.htm

Yo te recomendaria revisar y simplificar el algorimo. Resulta mas claro si haces dos bucles, uno para calcular el factorial (un for con 2 lineas de código) y luego otro para sumar las cifras del resultado (otro for con 3 lineas de código).

Yo lo he hecho así y usando BigInteger y el código es mucho más compacto y comprensible. Mi resultado para 100 es:

Código Salida Programa:

Factorial:93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
Suma: 648
 

No te voy a poner mi código ya que por lo que has dicho quieres intentarlo tu mismo, pero si no te sale a lo mejor te puede servir para que puedas refactorizar el tuyo.

Un saludo

[sixtoex]

Amigos, ya lo tengo solucionado jejejejeje!!

Por fín, dejo el código:

Código Java:

import java.math.BigInteger;
public class prueba
{
    public static void main(String[] args) {
        int valor = 1;
        BigInteger b1 = new BigInteger("1"); 
    int NumeroFin = 0;
    int PruebaTotal = 0;
    String NumeroFinCadena = "";
     //15511210043330985984000000                              // 2432902008176640000
        long fin = 100;
    BigInteger Sumatorio = new BigInteger("1");
    BigInteger Contador = new BigInteger("1");
    for(int i = 1; i <= fin;i++){
    b1 = b1.multiply(Sumatorio);
    Sumatorio = Sumatorio.add(Contador);
    if(i == fin){
    System.out.println(b1);
    NumeroFinCadena = String.valueOf(b1);
    PruebaTotal =NumeroFinCadena.length();
    
    }
    
    }
    BigInteger b2 = new BigInteger("1");  //10000000000000000000000000
    BigInteger Multiplicador = new BigInteger("10");
    int Compara = 0;
    Compara = b1.compareTo(b2);
    for(int i = 0 ; i <= fin;i++){
        for(int x = 0; x <= fin*500;x++){
            Compara = b1.compareTo(b2);
            if(Compara == 1){
                
                b2 = b2.multiply(Multiplicador);    
            }
            Compara = b1.compareTo(b2);
            if(Compara == -1){
                b2 = b2.divide(Multiplicador);
            }
        }
        System.out.println(b2);
        i = (int)fin +1;
    }
     
    BigInteger bDivide = new BigInteger("10");  
    long GuardarAnterior = 0;
    long ResultadoEntero = 0;
    for(int i = 0; i < PruebaTotal;i++){
    BigInteger Resul = b1.divide(b2);
    Resul = Resul.mod(bDivide);
    b2 = b2.divide(bDivide);
    ResultadoEntero = Resul.longValue();
    GuardarAnterior = ResultadoEntero + GuardarAnterior;
    }
    
    System.out.println(GuardarAnterior);
        }
 
    }
 

y por mi mismo, eso es lo que me da mas satisfacción, casi te pido el codigo jajajaja

[sixtoex]

Ya lo solucione amigos, casi te pido el código pero me puse y mira, al final lo conseguí:

i

Código Java:

import java.math.BigInteger;
public class prueba
{
    public static void main(String[] args) {
        int valor = 1;
        BigInteger b1 = new BigInteger("1"); 
    int NumeroFin = 0;
    int FinalNumero = 0;
    String NumeroFinCadena = "";
     //15511210043330985984000000                              // 2432902008176640000
        long fin = 100;
    BigInteger Sumatorio = new BigInteger("1");
    BigInteger Contador = new BigInteger("1");
    for(int i = 1; i <= fin;i++){
    b1 = b1.multiply(Sumatorio);
    Sumatorio = Sumatorio.add(Contador);
    if(i == fin){
    System.out.println(b1);
    NumeroFinCadena = String.valueOf(b1);
    FinalNumero =NumeroFinCadena.length();
    
    }
    
    }
    BigInteger b2 = new BigInteger("1");  //10000000000000000000000000
    BigInteger Multiplicador = new BigInteger("10");
    int Compara = 0;
    Compara = b1.compareTo(b2);
    for(int i = 0 ; i <= fin;i++){
        for(int x = 0; x <= fin*500;x++){
            Compara = b1.compareTo(b2);
            if(Compara == 1){
                
                b2 = b2.multiply(Multiplicador);    
            }
            Compara = b1.compareTo(b2);
            if(Compara == -1){
                b2 = b2.divide(Multiplicador);
            }
        }
        System.out.println(b2);
        i = (int)fin +1;
    }
     
    BigInteger bDivide = new BigInteger("10");  
    long GuardarAnterior = 0;
    long ResultadoEntero = 0;
    for(int i = 0; i < FinalNumero;i++){
    BigInteger Resul = b1.divide(b2);
    Resul = Resul.mod(bDivide);
    b2 = b2.divide(bDivide);
    ResultadoEntero = Resul.longValue();
    GuardarAnterior = ResultadoEntero + GuardarAnterior;
    }
    
    System.out.println(GuardarAnterior);
        }
 
    }
 

Saludos y muchisimas gracias por perder tiempo en mi

[Profesor_Falken]

Buenas,

Genial, te felicito.

Pongo ya entonces mi solución, que es un poco más compacta.

Código Java:

import java.math.BigInteger;
 
public class Factorial {
    private static final int NUMBER = 100;
 
    public static void main(String[] args) {
        int total = 0;
        BigInteger base = new BigInteger("10");
 
        BigInteger factorial = BigInteger.valueOf(1);
        for (int i = 1; i <= NUMBER; i++)
            factorial = factorial.multiply(BigInteger.valueOf(i));
 
        System.out.println("Factorial: " + factorial);
 
        int numDigits = factorial.toString().length();
 
        for(int i=0; i<numDigits; i++) {
            total += factorial.mod(base).intValue();
            factorial = factorial.divide(base);
        }
        System.out.println("Total: " + total);
    }
}
 

Un saludo