Ответ 1
Большие отрицательные числа - это значения, которые переполнены в определенные диапазоны; factorial(100) имеет более 32 двоичных нулей на конце, поэтому преобразование его в целое число приводит к нулю.
При вычислении факториала 100 (100!) С Java с использованием целых чисел получается 0
При этом:
int x = 100;
int result = 1;
for (int i = 1; i < (x + 1); i++) {
result = (result * i);
}
System.out.println(result);
Это явно потому, что результат слишком большой для целого числа, но я использую для получения больших отрицательных чисел для переполнения, а не 0.
Спасибо заранее!
Когда я переключаюсь на это:
int x = 100;
int result = 1;
for (int i = 1; i < (x + 1); i++) {
result = (result * i);
System.out.println(result);
}
Я получаю этот.
Ответы
Ответ 2
Есть 50 четных чисел от 1 до 100 включительно. Это означает, что факториал кратно 2 не менее 50 раз, другими словами, как двоичное число, последние 50 бит будут равны 0. (Фактически это больше, так как даже второе четное число кратно 2 * 2 и т.д.)
public static void main(String... args) {
BigInteger fact = fact(100);
System.out.println("fact(100) = " + fact);
System.out.println("fact(100).longValue() = " + fact.longValue());
System.out.println("fact(100).intValue() = " + fact.intValue());
int powerOfTwoCount = 0;
BigInteger two = BigInteger.valueOf(2);
while (fact.compareTo(BigInteger.ZERO) > 0 && fact.mod(two).equals(BigInteger.ZERO)) {
powerOfTwoCount++;
fact = fact.divide(two);
}
System.out.println("fact(100) powers of two = " + powerOfTwoCount);
}
private static BigInteger fact(long n) {
BigInteger result = BigInteger.ONE;
for (long i = 2; i <= n; i++)
result = result.multiply(BigInteger.valueOf(i));
return result;
}
печатает
fact(100) = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
fact(100).longValue() = 0
fact(100).intValue() = 0
fact(100) powers of two = 97
Это означает, что 97-битное целое число будет равно 0 для младших бит факта (100)
Действительно, число степеней 2 очень близко к n для факта (n). Для факта (10000) существует 9995 полномочий по два. Это связано с тем, что она представляет собой приблизительно сумму n раз степеней 1/2, давая полное приближение к n. то есть каждое второе число равно n/2, а каждый четвертый имеет дополнительную мощность 2 (+ n/4), и каждый восьмой имеет дополнительную мощность (+ n/8) и т.д. подходит к n как сумма.
Ответ 3
Чтобы посмотреть на причину, мы могли наблюдать простую факторизацию факториала.
fac( 1) = 1 = 2^0
fac( 2) = 2 = 2^1
fac( 3) = 2 * 3 = 2^1 * 3
fac( 4) = 2 * 2 * 2 * 3 = 2^3 * 3
fac( 5) = ... = 2^3 * 3 * 5
fac( 6) = ... = 2^4 * 3^2 * 5
fac( 7) = ... = 2^4 * ...
fac( 8) = ... = 2^7 * ...
fac( 9) = ... = 2^7 * ...
fac(10) = ... = 2^8 * ...
fac(11) = ... = 2^8 * ...
...
fac(29) = ... = 2^25 * ...
fac(30) = ... = 2^26 * ...
fac(31) = ... = 2^26 * ...
fac(32) = ... = 2^31 * ...
fac(33) = ... = 2^31 * ...
fac(34) = ... = 2^32 * ... <===
fac(35) = ... = 2^32 * ...
fac(36) = ... = 2^34 * ...
...
fac(95) = ... = 2^88 * ...
fac(96) = ... = 2^93 * ...
fac(97) = ... = 2^93 * ...
fac(98) = ... = 2^94 * ...
fac(99) = ... = 2^94 * ...
fac(100)= ... = 2^96 * ...
Показателем для 2 является число конечных нулей в представлении base-2, так как все остальные факторы нечетны и, таким образом, способствуют 1 в последней двоичной цифре для продукта.
Аналогичная схема работает и для других простых чисел, поэтому мы можем легко вычислить факторизацию fac(100):
fac(100) = 2^96 * 3^48 * 5^24 * 7^16 * 11^9 * 13^7 * 17^5 * 19^5 * 23^4 *
29^3 * 31^2 * 37^2 * 41^2 * 43^2 * 47^2 *
53 * 59 * 61 * 67 * 71 * 73 * 79 * 83 * 89 * 97
Итак, если наш компьютер сохранил числа в базе 3 и имел 48-трит-числа, fac(100) будет 0 (как fac(99) тоже, но fac(98) не будет: -)
Ответ 4
Хорошая проблема - ответ:
Факториал 33 (из-за отрицательных значений) -2147483648, который равен 0x80000000, или 0xFFFFFFFF80000000, если брать 64 бита. Умножение на 34 (следующий член) даст длинное значение 0xFFFFFFE600000000, которое при нажатии на int даст вам 0x00000000.
Очевидно, с этого момента вы останетесь с 0.
Ответ 5
Простое решение с использованием рекурсии и BigIntegers:
public static BigInteger factorial(int num){
if (num<=1)
return BigInteger.ONE;
else
return factorial(num-1).multiply(BigInteger.valueOf(num));
}
Вывод:
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
Ответ 6
(Нашел здесь, немного адаптировался к вопросу)
public static void main(String[] args) {
BigInteger fact = BigInteger.valueOf(1);
for (int i = 1; i <= 100; i++)
fact = fact.multiply(BigInteger.valueOf(i));
System.out.println(fact);
}
Ответ 7
Класс BigInteger на Java. Класс BigInteger используется для математической операции, которая включает в себя очень большие целочисленные вычисления, выходящие за пределы всех доступных примитивных типов данных.
Чтобы вычислить очень большое число, мы можем использовать BigInteger
Мол, если мы хотим рассчитать факториал 45, answer = 119622220865480194561963161495657715064383733760000000000
static void extraLongFactorials(int n) {
BigInteger fact = BigInteger.ONE;
for(int i=2; i<=n; i++){
fact = fact.multiply(BigInteger.valueOf(i));
}
System.out.println(fact);
}
Основными методами BigInteger являются BigInteger.ONE, BigInteger.ZERO, BigInteger.TEN, BigInteger.ValueOf()
Ответ 8
import java.util.*;
import java.math.*;
public class BigInteger_Factorial {
public static void main(String args []){
Scanner s = new Scanner(System.in);
BigInteger x,i,fac = new BigInteger("1");
x = s.nextBigInteger();
for(i=new BigInteger("1"); i.compareTo(x)<=0; i=i.add(BigInteger.ONE)){
fac = fac.multiply((i));
}
System.out.println(fac);
}
}
Вывод 100 в качестве ввода:
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
Выходное изображение:
Ответ 9
это переполнение наверняка, вы можете попробовать удвоить, 64-битное целое число, вероятно, слишком мало