Tại sao Java nghĩ rằng sản phẩm của tất cả các số từ 10 đến 99 là 0?

Khối mã sau đây cho đầu ra là 0.

public class HelloWorld{

    public static void main(String []args){
        int product = 1;
        for (int i = 10; i <= 99; i++) {
            product *= i;
        }
        System.out.println(product);
    }
}

Xin vui lòng ai đó có thể giải thích tại sao điều này xảy ra?

Đây là những gì chương trình làm ở mỗi bước:

          1 * 10 =          10
         10 * 11 =         110
        110 * 12 =        1320
       1320 * 13 =       17160
      17160 * 14 =      240240
     240240 * 15 =     3603600
    3603600 * 16 =    57657600
   57657600 * 17 =   980179200
  980179200 * 18 =   463356416
  463356416 * 19 =   213837312
  213837312 * 20 =   -18221056
  -18221056 * 21 =  -382642176
 -382642176 * 22 =   171806720
  171806720 * 23 =  -343412736
 -343412736 * 24 =   348028928
  348028928 * 25 =   110788608
  110788608 * 26 = -1414463488
-1414463488 * 27 =   464191488
  464191488 * 28 =   112459776
  112459776 * 29 = -1033633792
-1033633792 * 30 =  -944242688
 -944242688 * 31 =   793247744
  793247744 * 32 =  -385875968
 -385875968 * 33 =   150994944
  150994944 * 34 =   838860800
  838860800 * 35 =  -704643072
 -704643072 * 36 =   402653184
  402653184 * 37 =  2013265920
 2013265920 * 38 =  -805306368
 -805306368 * 39 = -1342177280
-1342177280 * 40 = -2147483648
-2147483648 * 41 = -2147483648
-2147483648 * 42 =           0
          0 * 43 =           0
          0 * 44 =           0
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
          0 * 97 =           0
          0 * 98 =           0

Lưu ý rằng trên một số bước, phép nhân dẫn đến một số nhỏ hơn (980179200 * 18 = 463356416) hoặc dấu không chính xác (213837312 * 20 = -18221056), chỉ ra rằng có tràn số nguyên. Nhưng số 0 đến từ đâu? Đọc tiếp.

Hãy nhớ rằng intloại dữ liệu là một số nguyên 32 bit , hai số nguyên bổ sung , đây là giải thích cho từng bước:

Operation         Result(1)     Binary Representation(2)                                           Result(3)
----------------  ------------  -----------------------------------------------------------------  ------------
          1 * 10            10                                                               1010            10
         10 * 11           110                                                            1101110           110
        110 * 12          1320                                                        10100101000          1320
       1320 * 13         17160                                                    100001100001000         17160
      17160 * 14        240240                                                 111010101001110000        240240
     240240 * 15       3603600                                             1101101111110010010000       3603600
    3603600 * 16      57657600                                         11011011111100100100000000      57657600
   57657600 * 17     980179200                                     111010011011000101100100000000     980179200
  980179200 * 18   17643225600                               100 00011011100111100100001000000000     463356416
  463356416 * 19    8803771904                                10 00001100101111101110011000000000     213837312
  213837312 * 20    4276746240                                   11111110111010011111100000000000     -18221056
  -18221056 * 21    -382642176  11111111111111111111111111111111 11101001001100010101100000000000    -382642176
 -382642176 * 22   -8418127872  11111111111111111111111111111110 00001010001111011001000000000000     171806720
  171806720 * 23    3951554560                                   11101011100001111111000000000000    -343412736
 -343412736 * 24   -8241905664  11111111111111111111111111111110 00010100101111101000000000000000     348028928
  348028928 * 25    8700723200                                10 00000110100110101000000000000000     110788608
  110788608 * 26    2880503808                                   10101011101100010000000000000000   -1414463488
-1414463488 * 27  -38190514176  11111111111111111111111111110111 00011011101010110000000000000000     464191488
  464191488 * 28   12997361664                                11 00000110101101000000000000000000     112459776
  112459776 * 29    3261333504                                   11000010011001000000000000000000   -1033633792
-1033633792 * 30  -31009013760  11111111111111111111111111111000 11000111101110000000000000000000    -944242688
 -944242688 * 31  -29271523328  11111111111111111111111111111001 00101111010010000000000000000000     793247744
  793247744 * 32   25383927808                               101 11101001000000000000000000000000    -385875968
 -385875968 * 33  -12733906944  11111111111111111111111111111101 00001001000000000000000000000000     150994944
  150994944 * 34    5133828096                                 1 00110010000000000000000000000000     838860800
  838860800 * 35   29360128000                               110 11010110000000000000000000000000    -704643072
 -704643072 * 36  -25367150592  11111111111111111111111111111010 00011000000000000000000000000000     402653184
  402653184 * 37   14898167808                                11 01111000000000000000000000000000    2013265920
 2013265920 * 38   76504104960                             10001 11010000000000000000000000000000    -805306368
 -805306368 * 39  -31406948352  11111111111111111111111111111000 10110000000000000000000000000000   -1342177280
-1342177280 * 40  -53687091200  11111111111111111111111111110011 10000000000000000000000000000000   -2147483648
-2147483648 * 41  -88046829568  11111111111111111111111111101011 10000000000000000000000000000000   -2147483648
-2147483648 * 42  -90194313216  11111111111111111111111111101011 00000000000000000000000000000000             0
          0 * 43             0                                                                  0             0
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
          0 * 98             0                                                                  0             0

1. là kết quả chính xác
2. là biểu diễn bên trong của kết quả (64 bit được sử dụng để minh họa)
3. là kết quả được biểu thị bằng phần bù hai của 32 bit thấp hơn

Chúng tôi biết rằng nhân một số với một số chẵn:

• dịch chuyển các bit về bên trái và thêm các bit 0 về bên phải
• kết quả là số chẵn

Vì vậy, về cơ bản, chương trình của bạn nhân một số chẵn với một số khác lặp đi lặp lại các bit kết quả bắt đầu từ bên phải.

PS: Nếu các phép nhân chỉ liên quan đến số lẻ thì kết quả sẽ không trở thành số không.

Phép nhân máy tính đang thực sự xảy ra modulo 2 ^ 32. Khi bạn đã tích lũy đủ số lượng lũy ​​thừa của hai trong bội số, thì tất cả các giá trị sẽ là 0.

Ở đây chúng ta có tất cả các số chẵn trong chuỗi, cùng với sức mạnh tối đa của hai số đó chia cho số lượng và sức mạnh tích lũy của hai

num   max2  total
10    2     1
12    4     3
14    2     4
16    16    8
18    2     9
20    4    11
22    2    12
24    8    15
26    2    16
28    4    18
30    2    19
32    32   24
34    2    25
36    4    27
38    2    28
40    8    31
42    2    32

Sản phẩm lên tới 42 bằng x * 2 ^ 32 = 0 (mod 2 ^ 32). Chuỗi các quyền hạn của hai có liên quan đến mã Gray (trong số những thứ khác) và xuất hiện dưới dạng https://oeis.org/A001511 .

EDIT: để xem tại sao các câu trả lời khác cho câu hỏi này không đầy đủ, hãy xem xét thực tế là cùng một chương trình, chỉ giới hạn ở các số nguyên lẻ, sẽ không hội tụ về 0, mặc dù tất cả đều tràn.

Nó trông giống như một số nguyên tràn .

Hãy xem này

BigDecimal product=new BigDecimal(1);
for(int i=10;i<99;i++){
    product=product.multiply(new BigDecimal(i));
}
System.out.println(product);

Đầu ra:

25977982938941930515945176761070443325092850981258133993315252362474391176210383043658995147728530422794328291965962468114563072000000000000000000000

Đầu ra không còn là một intgiá trị. Sau đó, bạn sẽ nhận được giá trị sai vì tràn.

Nếu nó tràn ra, nó sẽ quay trở lại giá trị tối thiểu và tiếp tục từ đó. Nếu nó chảy xuống, nó sẽ quay trở lại giá trị tối đa và tiếp tục từ đó.

Thêm thông tin

Chỉnh sửa .

Hãy thay đổi mã của bạn như sau

int product = 1;
for (int i = 10; i < 99; i++) {
   product *= i;
   System.out.println(product);
}

Đặt ra:

10
110
1320
17160
240240
3603600
57657600
980179200
463356416
213837312
-18221056
-382642176
171806720
-343412736
348028928
110788608
-1414463488
464191488
112459776
-1033633792
-944242688
793247744
-385875968
150994944
838860800
-704643072
402653184
2013265920
-805306368
-1342177280
-2147483648
-2147483648>>>binary representation is 11111111111111111111111111101011 10000000000000000000000000000000 
 0 >>> here binary representation will become 11111111111111111111111111101011 00000000000000000000000000000000 
 ----
 0

Đó là vì tràn số nguyên. Khi bạn nhân nhiều số chẵn với nhau, số nhị phân sẽ nhận được rất nhiều số 0 ở cuối. Khi bạn có hơn 32 số 0 ở cuối int, nó sẽ cuộn qua 0.

Để giúp bạn hình dung điều này, đây là các phép nhân trong hex được tính trên một loại số sẽ không tràn. Xem cách các số 0 ở cuối phát triển chậm và lưu ý rằng một số intđược tạo thành từ 8 chữ số cuối cùng. Sau khi nhân với 42 (0x2A), tất cả 32 bit của một intlà số 0!

                                     1 (int: 00000001) * 0A =
                                     A (int: 0000000A) * 0B =
                                    6E (int: 0000006E) * 0C =
                                   528 (int: 00000528) * 0D =
                                  4308 (int: 00004308) * 0E =
                                 3AA70 (int: 0003AA70) * 0F =
                                36FC90 (int: 0036FC90) * 10 =
                               36FC900 (int: 036FC900) * 11 =
                              3A6C5900 (int: 3A6C5900) * 12 =
                             41B9E4200 (int: 1B9E4200) * 13 =
                            4E0CBEE600 (int: 0CBEE600) * 14 =
                           618FEE9F800 (int: FEE9F800) * 15 =
                          800CE9315800 (int: E9315800) * 16 =
                         B011C0A3D9000 (int: 0A3D9000) * 17 =
                        FD1984EB87F000 (int: EB87F000) * 18 =
                      17BA647614BE8000 (int: 14BE8000) * 19 =
                     25133CF88069A8000 (int: 069A8000) * 1A =
                    3C3F4313D0ABB10000 (int: ABB10000) * 1B =
                   65AAC1317021BAB0000 (int: 1BAB0000) * 1C =
                  B1EAD216843B06B40000 (int: 06B40000) * 1D =
                142799CC8CFAAFC2640000 (int: C2640000) * 1E =
               25CA405F8856098C7B80000 (int: C7B80000) * 1F =
              4937DCB91826B2802F480000 (int: 2F480000) * 20 =
             926FB972304D65005E9000000 (int: E9000000) * 21 =
           12E066E7B839FA050C309000000 (int: 09000000) * 22 =
          281CDAAC677B334AB9E732000000 (int: 32000000) * 23 =
         57BF1E59225D803376A9BD6000000 (int: D6000000) * 24 =
        C56E04488D526073CAFDEA18000000 (int: 18000000) * 25 =
      1C88E69E7C6CE7F0BC56B2D578000000 (int: 78000000) * 26 =
     43C523B86782A6DBBF4DE8BAFD0000000 (int: D0000000) * 27 =
    A53087117C4E76B7A24DE747C8B0000000 (int: B0000000) * 28 =
  19CF951ABB6C428CB15C2C23375B80000000 (int: 80000000) * 29 =
 4223EE1480456A88867C311A3DDA780000000 (int: 80000000) * 2A =
AD9E50F5D0B637A6610600E4E25D7B00000000 (int: 00000000)

Một nơi nào đó ở giữa bạn nhận được 0như là sản phẩm. Vì vậy, toàn bộ sản phẩm của bạn sẽ là 0.

Trong trường hợp của bạn :

for (int i = 10; i < 99; i++) {
    if (product < Integer.MAX_VALUE)
        System.out.println(product);
    product *= i;
}
// System.out.println(product);

System.out.println(-2147483648 * EvenValueOfi); // --> this is the culprit (Credits : Kocko's answer )

O/P :
1
10
110
1320
17160
240240
3603600
57657600
980179200
463356416
213837312
-18221056
-382642176
171806720
-343412736
348028928
110788608
-1414463488
464191488
112459776
-1033633792
-944242688
793247744
-385875968
150994944
838860800
-704643072
402653184
2013265920
-805306368
-1342177280  --> Multiplying this and the current value of `i` will also give -2147483648 (INT overflow)
-2147483648  --> Multiplying this and the current value of `i` will also give -2147483648 (INT overflow)

-2147483648  ->  Multiplying this and the current value of 'i' will give 0 (INT overflow)
0
0
0

Mỗi khi bạn nhân giá trị hiện tại ivới số bạn nhận được 0làm đầu ra.

Do nhiều câu trả lời hiện có cho các chi tiết triển khai của Java và đầu ra gỡ lỗi, chúng ta hãy xem toán học đằng sau phép nhân nhị phân để thực sự trả lời lý do tại sao.

Nhận xét của @kasperd đi đúng hướng. Giả sử bạn không nhân trực tiếp với số mà thay vào đó là các thừa số nguyên tố của số đó. Hơn rất nhiều số sẽ có 2 là một thừa số nguyên tố. Trong nhị phân, điều này tương đương với một ca trái. Bằng cách giao hoán, chúng ta có thể nhân với các thừa số nguyên tố của 2 trước. Điều đó có nghĩa là chúng tôi chỉ làm một ca trái.

Khi xem xét các quy tắc nhân nhị phân, trường hợp duy nhất trong đó 1 sẽ dẫn đến một vị trí chữ số cụ thể là khi cả hai giá trị toán hạng là một.

Vì vậy, hiệu ứng của dịch chuyển trái là vị trí bit thấp nhất của 1 khi nhân thêm kết quả được tăng lên.

Vì số nguyên chỉ chứa các bit thứ tự thấp nhất, nên tất cả chúng sẽ được đặt thành 0 khi hệ số nguyên tố 2 được xác định thường xuyên đủ trong kết quả.

Lưu ý rằng đại diện bổ sung của hai không quan tâm đến phân tích này, vì dấu hiệu của kết quả nhân có thể được tính độc lập với số kết quả. Điều đó có nghĩa là nếu giá trị tràn và trở thành âm, các bit thứ tự thấp nhất được biểu diễn là 1, nhưng trong quá trình nhân, chúng được xử lý lại là 0.

Nếu tôi chạy mã này, tôi nhận được tất cả -

          1 * 10 =          10
         10 * 11 =         110
        110 * 12 =        1320
       1320 * 13 =       17160
      17160 * 14 =      240240
     240240 * 15 =     3603600
    3603600 * 16 =    57657600
   57657600 * 17 =   980179200
  980179200 * 18 =   463356416 <- Integer Overflow (17643225600)
  463356416 * 19 =   213837312
  213837312 * 20 =   -18221056
  -18221056 * 21 =  -382642176
 -382642176 * 22 =   171806720
  171806720 * 23 =  -343412736
 -343412736 * 24 =   348028928
  348028928 * 25 =   110788608
  110788608 * 26 = -1414463488
-1414463488 * 27 =   464191488
  464191488 * 28 =   112459776
  112459776 * 29 = -1033633792
-1033633792 * 30 =  -944242688
 -944242688 * 31 =   793247744
  793247744 * 32 =  -385875968
 -385875968 * 33 =   150994944
  150994944 * 34 =   838860800
  838860800 * 35 =  -704643072
 -704643072 * 36 =   402653184
  402653184 * 37 =  2013265920
 2013265920 * 38 =  -805306368
 -805306368 * 39 = -1342177280
-1342177280 * 40 = -2147483648
-2147483648 * 41 = -2147483648
-2147483648 * 42 =           0 <- produce 0 
          0 * 43 =           0

Nguyên nhân tràn số nguyên -

980179200 * 18 =   463356416 (should be 17643225600)

17643225600 : 10000011011100111100100001000000000 <-Actual
MAX_Integer :     1111111111111111111111111111111
463356416   :     0011011100111100100001000000000 <- 32 bit Integer

Sản xuất 0 nguyên nhân -

-2147483648 * 42 =           0 (should be -90194313216)

-90194313216: 1010100000000000000000000000000000000 <- Actual
MAX_Integer :       1111111111111111111111111111111
0           :      00000000000000000000000000000000 <- 32 bit Integer

Cuối cùng, phép tính tràn ra, và cuối cùng là tràn đó dẫn đến một sản phẩm bằng không; Điều đó xảy ra khi product == -2147483648và i == 42. Hãy thử mã này để tự xác minh mã (hoặc chạy mã tại đây ):

import java.math.BigInteger;

class Ideone {
    public static void main (String[] args) throws java.lang.Exception {
        System.out.println("Result: " + (-2147483648 * 42));
    }
}

Một khi nó bằng không, tất nhiên nó vẫn bằng không. Đây là một số mã sẽ tạo ra kết quả chính xác hơn (bạn có thể chạy mã ở đây ):

import java.math.BigInteger;

class Ideone {
    public static void main (String[] args) throws java.lang.Exception {
        BigInteger p = BigInteger.valueOf(1);
        BigInteger start = BigInteger.valueOf(10);
        BigInteger end = BigInteger.valueOf(99);
        for(BigInteger i = start; i.compareTo(end) < 0; i = i.add(BigInteger.ONE)){
            p = p.multiply(i);
            System.out.println("p: " + p);
        }
        System.out.println("\nProduct: " + p);
    }
}

Nó là một số nguyên tràn.

Kiểu dữ liệu int là 4 byte hoặc 32 bit. Do đó, các số lớn hơn 2 ^ (32 - 1) - 1 (2.147.483.647) không thể được lưu trữ trong loại dữ liệu này. Giá trị số của bạn sẽ không chính xác.

Đối với số lượng rất lớn, bạn sẽ muốn nhập và sử dụng lớp java.math.BigInteger:

BigInteger product = BigInteger.ONE;
for (long i = 10; i < 99; i++) 
    product = product.multiply(BigInteger.valueOf(i));
System.out.println(product.toString());

GHI CHÚ: Đối với các giá trị số vẫn còn quá lớn đối với kiểu dữ liệu int, nhưng đủ nhỏ để vừa trong 8 byte (giá trị tuyệt đối nhỏ hơn hoặc bằng 2 ^ (64 - 1) - 1), có lẽ bạn nên sử dụng longnguyên hàm.

Các vấn đề thực hành của HackerRank (www.hackerrank.com), chẳng hạn như phần thực hành Thuật toán, ( https://www.hackerrank.com/domains/alerskyms/warmup ) bao gồm một số câu hỏi số lượng lớn rất tốt giúp thực hành tốt về cách suy nghĩ về loại dữ liệu phù hợp để sử dụng.