Dlaczego Java myśli, że iloczyn wszystkich liczb od 10 do 99 jest równy 0?

131

Poniższy blok kodów daje wynik jako 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);
    }
}

Czy ktoś może wyjaśnić, dlaczego tak się dzieje?

java  integer  integer-overflow 
— Aniruddha Sarkar
źródło
106
Najprawdopodobniej masz przepełnienie całkowitoliczbowe.
— TheLostMind
68
Jeśli weźmiesz pod uwagę czynniki pierwsze w produkcie, 2pojawi się około 90 razy. Oznacza to, że będziesz potrzebować zmiennej z co najmniej 90 bitami, aby uzyskać niezerowe dane wyjściowe. 32 i 64 to mniej niż 90. Aby obliczyć liczby całkowite większe niż słowa rodzime, musisz użyć dowolnej klasy dużych liczb całkowitych dostępnej w wybranym języku.
— kasperd
62
Technicznie rzecz biorąc, jest to iloczyn liczb od 10 do 98.
— AShelly
45
Co? Dlaczego to pytanie zostało zamknięte jako duplikat pytania, które jest zamykane jako duplikat tego pytania ?
— Salman A
82
Mam 99 problemów i 2147483648 nie 1.
— glenatron

Odpowiedzi:

425

Oto, co program robi na każdym kroku:

          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

Zwróć uwagę, że w niektórych krokach mnożenie daje mniejszą liczbę (980179200 * 18 = 463356416) lub nieprawidłowy znak (213837312 * 20 = -18221056), co wskazuje, że wystąpiło przepełnienie liczby całkowitej. Ale skąd pochodzi zero? Czytaj.

Pamiętając, że inttyp danych jest 32-bitowa , uzupełnienie dwójkowe całkowitą, tutaj jest wyjaśnienie każdego etapu:

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. to poprawny wynik
  2. to wewnętrzna reprezentacja wyniku (do ilustracji używane są 64 bity)
  3. jest wynikiem reprezentowanym przez uzupełnienie do dwóch niższych 32 bitów

Wiemy, że pomnożenie liczby przez liczbę parzystą:

  • przesuwa bity w lewo i dodaje zero bitów w prawo
  • daje parzystą liczbę

Zasadniczo twój program wielokrotnie mnoży liczbę parzystą przez inną, co zeruje bity wyniku, zaczynając od prawej.

PS: Jeśli mnożenia obejmowały tylko liczby nieparzyste, wynik nie będzie zerowy.

— Salman A
źródło
15
Reprezentacja Hex pomogła mi zrozumieć, co się tutaj dzieje. Dzięki za wytłumaczenie!
1
Tak, byłoby bardziej pouczające, gdybyś zmodyfikował swój program tak, aby wypisał również wartości szesnastkowe z długiej listy.
— Hot Licks
4
Ta odpowiedź jest poprawna, ale jest tak dużo bałaganu. Ostatnich pięć wierszy jest jej sercem i nigdzie tak naprawdę nie ilustruje, jak dokładnie to ma znaczenie. (Ale można to rozwikłać z gigantycznego stołu.)
— Rex Kerr
6
Innymi słowy, kumulujesz współczynniki 2. Niektóre liczby same w sobie dają wiele czynników 2, na przykład 12, 16 i 20. Każdy czynnik 2 przesunie w prawo wszystkie bity wszystkich kolejnych wyników, pozostawiając zera jako symbole zastępcze. Po 32-krotnym przesunięciu w prawo pozostaje tylko 32 zastępcze zera.
— Keen
2
Podobny efekt można zaobserwować także w przypadku podstawy 10. Spróbuj pomnożyć dowolną serię kolejnych liczb całkowitych, za każdym razem, gdy pomnożymy przez liczbę podzielną przez 10, dodajemy co najmniej jedno zero na końcu iloczynu i nie można tego zera usunąć z iloczynu przez pomnożenie liczb całkowitych. W pewnym momencie wszystkie n-te najmniej znaczące cyfry zostaną wypełnione zerami i jeśli wykonujesz arytmetykę do modulo 10 ** m (co skutkuje odcięciem wszystkiego oprócz m-tej najmniejszej cyfry), wtedy skończy się na zerowaniu. Podobnie jest z innymi podstawami.
— Lie Ryan,
70

Mnożenie komputera naprawdę się dzieje modulo 2 ^ 32. Kiedy zgromadzisz wystarczającą liczbę potęg dwóch w mnożniku, wszystkie wartości będą równe 0.

Tutaj mamy wszystkie liczby parzyste w serii, wraz z maksymalną potęgą dwóch, która dzieli liczbę, i łączną potęgą dwóch

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

Iloczyn do 42 równa się x * 2 ^ 32 = 0 (mod 2 ^ 32). Sekwencja potęg dwóch jest związana między innymi z kodami Graya i pojawia się jako https://oeis.org/A001511 .

EDYCJA: aby zobaczyć, dlaczego inne odpowiedzi na to pytanie są niekompletne, weź pod uwagę fakt, że ten sam program, ograniczony tylko do nieparzystych liczb całkowitych, nie zbiegałby się do 0, pomimo całego przepełnienia.

— user295691
źródło
Yay! Wreszcie poprawna odpowiedź. Ludzie powinni bardziej zauważyć tę odpowiedź!
— Rex Kerr
To jedyna poprawna odpowiedź. Wszyscy inni nie wyjaśniają dlaczego .
— Olivier Grégoire,
5
@ OlivierGrégoire Nie zgadzam się; Myślę, że przyjęta odpowiedź jest poprawna i daje doskonałe wyjaśnienie. Ten jest po prostu bardziej bezpośredni.
— David Z
1
Mam nadzieję, że więcej osób zobaczy tę odpowiedź. Tutaj podano pierwotną przyczynę!
— lanpa
1
@DavidZ: Zgoda; przyjęta odpowiedź jest w większości poprawna - mój post tak naprawdę nie odnosi się do „dlaczego” mojego zdania początkowego. Ale zaakceptowana odpowiedź jest najbliższa odpowiedzi na pytanie „dlaczego zero”, ale nie wyjaśnia „dlaczego 42” - jest tylko 16 liczb parzystych między 10 a 42
— użytkownik295691
34

Wygląda na przepełnienie liczby całkowitej .

Spójrz na to

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

Wynik:

25977982938941930515945176761070443325092850981258133993315252362474391176210383043658995147728530422794328291965962468114563072000000000000000000000

Wynik nie jest już intwartością. Wtedy otrzymasz błędną wartość z powodu przepełnienia.

Jeśli się przepełni, wraca do wartości minimalnej i kontynuuje od tego momentu. Jeśli spada, wraca do wartości maksymalnej i kontynuuje od tego momentu.

Więcej informacji

Edytuj .

Zmieńmy Twój kod w następujący sposób

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

Wynik:

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
— Ruchira Gayan Ranaweera
źródło
22

To z powodu przepełnienia liczb całkowitych. Kiedy pomnożymy razem wiele liczb parzystych, liczba binarna otrzyma wiele końcowych zer. Jeśli masz więcej niż 32 zera końcowe dla an int, przechodzi on do0 .

Aby pomóc ci to zwizualizować, oto mnożenia szesnastkowe obliczone dla typu liczby, która nie przepełni się. Zobacz, jak końcowe zera powoli rosną i zwróć uwagę, że an intskłada się z ostatnich 8 cyfr szesnastkowych. Po pomnożeniu przez 42 (0x2A) wszystkie 32 bity intsą zerami!

                                     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)
— Tim S.
źródło
1
To jest trochę mylące. Chociaż poprawnie pokazuje, dlaczego dochodzi do zera, każda wartość jest przechowywana w 32-bitowej liczbie int po pomnożeniu, więc powinna zostać obcięta po każdym kroku. Sposób, w jaki napisałeś odpowiedź, sugeruje, że nie jest ona obcinana do momentu zakończenia pętli for. Byłoby lepiej, gdybyś pokazał tylko ostatnie 8 cyfr dla każdego kroku.
— RyNo
@KamikazeScotsman Poprawiłem odpowiedź na podstawie Twojej sugestii. Mniej zbędnych zer, większa 32-bitowa widoczność int.
— Tim S.
1
+1 za pokazanie aktualnej wartości w porównaniu z 32-bitową wartością na każdym etapie, podkreślając, że wartość jest obcinana ...
— kwah
14

Gdzieś pośrodku otrzymujesz 0produkt. Zatem cały Twój produkt będzie wynosił 0.

W Twoim przypadku :

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

Za każdym razem, gdy pomnożymy bieżącą wartość iprzez liczbę otrzymaną 0jako wynik.

— TheLostMind
źródło
@KickButtowski - Pomnóż liczby .. Dowiesz się dlaczego: P
— TheLostMind
@KickButtowski - 0 pomnożone przez dowolną inną liczbę będzie zawsze dawać 0 po tym, jak przepełnienie zwróci 0 w dowolnym momencie.
— Mr Moose
Zrobiłem, ale myślę, że powinieneś być bardziej informacyjny, aby inni też mogli się nauczyć
— Kick Buttowski
@KickButtowski - zaktualizowałem odpowiedź. Sprawdź część OP.
— TheLostMind
8
@KickButtowski: To dlatego, że zawijanie przepełnienia odbywa się z potęgą dwóch. Zasadniczo OP oblicza {10 x 11 x 12 x ... x 98} modulo 2 ^ 32. Ponieważ wielokrotności 2 występują w tym iloczynu znacznie więcej niż 32 razy, wynik jest zerowy.
— ruakh
12

Ponieważ wiele z istniejących odpowiedzi wskazuje na szczegóły implementacji języka Java i wyniki debugowania, przyjrzyjmy się matematyce stojącej za mnożeniem binarnym, aby naprawdę odpowiedzieć na pytanie, dlaczego.

Komentarz @kasperd idzie w dobrym kierunku. Załóżmy, że nie mnożysz bezpośrednio przez liczbę, ale zamiast tego przez czynniki pierwsze tej liczby. Niż wiele liczb będzie miało 2 jako czynnik pierwszy. W systemie binarnym jest to przesunięcie w lewo. Przez przemienność możemy najpierw pomnożyć przez czynniki pierwsze 2. Oznacza to, że po prostu wykonujemy przesunięcie w lewo.

Patrząc na binarne reguły mnożenia, jedynym przypadkiem, w którym 1 da w wyniku określoną pozycję cyfry, jest sytuacja, w której obie wartości operandów są równe jeden.

Zatem efekt przesunięcia w lewo jest taki, że najniższe położenie bitu 1 przy dalszym mnożeniu wyniku jest zwiększane.

Ponieważ liczba całkowita zawiera tylko bity najniższego rzędu, wszystkie zostaną ustawione na 0, gdy w wyniku dostatecznie często występuje czynnik pierwszy 2.

Zauważ, że reprezentacja dopełnienia do dwóch nie jest interesująca dla tej analizy, ponieważ znak wyniku mnożenia można obliczyć niezależnie od wynikowej liczby. Oznacza to, że jeśli wartość przepełni się i stanie się ujemna, bity najniższego rzędu są reprezentowane jako 1, ale podczas mnożenia są ponownie traktowane jako 0.

— SpaceTrucker
źródło
7

Jeśli uruchomię ten kod Co otrzymam wszystko -

          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

Przyczyna przepełnienia liczby całkowitej -

980179200 * 18 =   463356416 (should be 17643225600)

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

Wyprodukuj 0 przyczyn -

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

-90194313216: 1010100000000000000000000000000000000 <- Actual
MAX_Integer :       1111111111111111111111111111111
0           :      00000000000000000000000000000000 <- 32 bit Integer
— Subhrajyoti Majumder
źródło
6

Ostatecznie obliczenia przepełniają się i ostatecznie to przepełnienie prowadzi do iloczynu zerowego; to się dzieje, gdy product == -2147483648i i == 42. Wypróbuj ten kod, aby zweryfikować go samodzielnie (lub uruchom kod tutaj ):

import java.math.BigInteger;

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

Gdy jest zero, oczywiście pozostaje zero. Oto kod, który da dokładniejszy wynik (możesz uruchomić kod tutaj ):

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);
    }
}
— Trevor
źródło
Przepełnia (w dokładnym znaczeniu tego słowa) na długo przed 42. iteracją - w wieku 19 lat jest już przepełniony, ponieważ f (19) <f (18)
— user295691
Tak, ale przepełnienie nie prowadzi do lub skutkuje iloczynem zerowym aż do 42. iteracji.
— Trevor
Myślę, że chodzi mi o to, że nie odpowiadasz na pytanie „dlaczego” - dlaczego skumulowany produkt miałby kiedykolwiek przejść przez 0? Odpowiedź Tima S. daje pewne wskazówki, dlaczego, ale prawdziwa odpowiedź leży w arytmetyce modularnej.
— user295691
Pytanie nie dotyczy tego, dlaczego produkt przechodzi przez zero. Pyta, dlaczego kod daje zero. Innymi słowy, myślę, że OP jest bardziej zainteresowany dynamiką języka Java niż arytmetyką modularną, ale być może się mylę. Nie byłby to pierwszy raz, kiedy źle zinterpretowałbym czyjeś pytanie.
— Trevor
na przykład, gdyby ten program wziął iloczyn wszystkich liczb nieparzystych od 11 do 99, to nie osiągnąłby zera. Twoja odpowiedź tak naprawdę nie wyjaśnia, dlaczego tak się stało.
— user295691
1

Jest to przepełnienie całkowitoliczbowe.

Typ danych int to 4 bajty lub 32 bity. Dlatego liczby większe niż 2 ^ (32 - 1) - 1 (2 147 483 647) nie mogą być przechowywane w tym typie danych. Twoje wartości liczbowe będą nieprawidłowe.

W przypadku bardzo dużych liczb będziesz chciał zaimportować klasę i używać jej 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());

UWAGA: W przypadku wartości liczbowych, które są nadal zbyt duże dla typu danych int, ale wystarczająco małe, aby zmieścić się w 8 bajtach (wartość bezwzględna mniejsza lub równa 2 ^ (64 - 1) - 1), prawdopodobnie powinieneś użyć longprymitywu.

Praktyczne problemy HackerRank (www.hackerrank.com), takie jak sekcja ćwiczeń algorytmów, ( https://www.hackerrank.com/domains/algorithms/warmup ) obejmują kilka bardzo dobrych, dużych pytań, które dają dobre praktyki dotyczące tego, jak pomyśl o odpowiednim typie danych do użycia.

— La-comadreja
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.