Warum glaubt Java, dass das Produkt aller Zahlen von 10 bis 99 0 ist?

131

Der folgende Codeblock gibt die Ausgabe als 0 an.

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);
    }
}

Kann mir bitte jemand erklären, warum das passiert?

java  integer  integer-overflow 
— Aniruddha Sarkar
quelle
106
Sie haben höchstwahrscheinlich einen ganzzahligen Überlauf.
— TheLostMind
68
Wenn Sie die Hauptfaktoren des Produkts berücksichtigen, werden Sie 2ungefähr 90 Mal angezeigt. Das bedeutet, dass Sie eine Variable mit mindestens 90 Bit benötigen, um eine Ausgabe ungleich Null zu erhalten. 32 und 64 sind beide kleiner als 90. Um Ganzzahlen zu berechnen, die größer als die nativen Wörter sind, müssen Sie eine beliebige große Ganzzahlklasse verwenden, die in der von Ihnen gewählten Sprache verfügbar ist.
— Kasperd
62
Technisch gesehen ist dies das Produkt von Zahlen von 10 bis 98.
— AShelly
45
Was? Warum wurde diese Frage als Duplikat einer Frage geschlossen, die als Duplikat dieser Frage geschlossen wird ?
— Salman A
82
Habe 99 Probleme und 2147483648 aint 1.
— Glenatron

Antworten:

425

Folgendes macht das Programm bei jedem Schritt:

          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

Beachten Sie, dass bei einigen Schritten die Multiplikation zu einer kleineren Zahl (980179200 * 18 = 463356416) oder einem falschen Vorzeichen (213837312 * 20 = -18221056) führt, was darauf hinweist, dass ein ganzzahliger Überlauf aufgetreten ist. Aber woher kommt die Null? Weiter lesen.

Wenn man bedenkt , dass intDatentyp ist ein 32-Bit unterzeichnet , Zweier-Komplement Ganzzahl, hier ist eine Erklärung der einzelnen Schritte:

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. ist das richtige Ergebnis
  2. ist die interne Darstellung des Ergebnisses (64 Bit werden zur Veranschaulichung verwendet)
  3. ist das Ergebnis, das durch das Zweierkomplement der unteren 32 Bits dargestellt wird

Wir wissen, dass eine Zahl mit einer geraden Zahl multipliziert wird:

  • verschiebt die Bits nach links und fügt null Bits nach rechts hinzu
  • ergibt eine gerade Zahl

Im Grunde genommen multipliziert Ihr Programm eine gerade Zahl wiederholt mit einer anderen Zahl, wodurch die Ergebnisbits beginnend von rechts auf Null gesetzt werden.

PS: Wenn die Multiplikationen nur ungerade Zahlen beinhalten, wird das Ergebnis nicht Null.

— Salman A.
quelle
15
Die Hex-Darstellung hat mir geholfen, mich auf das einzulassen, was hier geschah. Danke fürs klarstellen!
1
Ja, es wäre lehrreicher, wenn Sie Ihr Programm so ändern würden, dass auch die Hex-Werte in der langen Liste ausgedruckt werden.
— Hot Licks
4
Diese Antwort ist richtig, aber es gibt so viel Unordnung. Die letzten fünf Zeilen sind das Herzstück davon, und nirgendwo zeigt es wirklich, wo genau das ins Spiel kommt. (Aber man kann es vom riesigen Tisch
— Rex Kerr
6
Anders ausgedrückt, Sie akkumulieren Faktoren von 2. Einige Zahlen geben Ihnen mehrere Faktoren von 2 für sich, wie 12, 16 und 20. Jeder Faktor von 2 verschiebt alle Bits aller Ihrer nachfolgenden Ergebnisse nach rechts und lässt Nullen als Platzhalter. Wenn Sie 32 Mal nach rechts verschoben haben, bleiben nur 32 Platzhalter-Nullen übrig.
— Keen
2
Ein ähnlicher Effekt ist auch in Basis 10 zu sehen. Versuchen Sie, eine Reihe aufeinanderfolgender Ganzzahlen zu multiplizieren. Jedes Mal, wenn Sie mit einer durch 10 teilbaren Zahl multiplizieren, fügen Sie am Ende des Produkts mindestens eine Null hinzu, und es ist unmöglich, diese Null zu entfernen aus dem Produkt durch Multiplikation von ganzen Zahlen. Irgendwann werden alle n-ten niedrigstwertigen Ziffern mit Nullen gefüllt, und wenn Sie mit einem Modulo 10 ** m rechnen (was bewirkt, dass alles außer den m-ten niedrigstwertigen Ziffern abgeschnitten wird), dann wird es auf Null drehen. Ebenso bei allen anderen Basen.
— Lie Ryan
70

Computermultiplikation geschieht wirklich Modulo 2 ^ 32. Sobald Sie im Multiplikanden genügend Zweierpotenzen gesammelt haben, sind alle Werte 0.

Hier haben wir alle geraden Zahlen in der Reihe, zusammen mit der maximalen Potenz von zwei, die die Zahl teilt, und der kumulativen Potenz von zwei

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

Das Produkt bis 42 ist gleich x * 2 ^ 32 = 0 (mod 2 ^ 32). Die Reihenfolge der Zweierpotenzen bezieht sich (unter anderem) auf Gray-Codes und wird als https://oeis.org/A001511 angezeigt .

BEARBEITEN: Um zu sehen, warum andere Antworten auf diese Frage unvollständig sind, berücksichtigen Sie die Tatsache, dass dasselbe Programm, das nur auf ungerade ganze Zahlen beschränkt ist , trotz aller Überläufe nicht gegen 0 konvergieren würde .

— user295691
quelle
Yay! Endlich die richtige Antwort. Die Leute sollten diese Antwort mehr bemerken!
— Rex Kerr
Dies ist die einzig richtige Antwort. Alle anderen erklären nicht warum .
— Olivier Grégoire
5
@ OlivierGrégoire Ich bin anderer Meinung; Ich denke, die akzeptierte Antwort ist richtig und gibt eine vollkommen gute Erklärung. Dieser ist nur direkter.
— David Z
1
Ich hoffe, dass mehr Leute diese Antwort sehen. Die Grundursache ist hier angegeben!
— Lanpa
1
@ DavidZ: Einverstanden; Die akzeptierte Antwort ist größtenteils richtig - mein Beitrag spricht nicht wirklich das "Warum" meines Eröffnungssatzes an. Aber der Abschluss der akzeptierten Antwort kommt einer Antwort auf "Warum Null" am nächsten, erklärt aber nicht "Warum 42" - es gibt nur 16 gerade Zahlen zwischen 10 und 42
— user295691
34

Es sieht aus wie ein ganzzahliger Überlauf .

Schau dir das an

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

Ausgabe:

25977982938941930515945176761070443325092850981258133993315252362474391176210383043658995147728530422794328291965962468114563072000000000000000000000

Ausgabe ist kein intWert mehr. Dann erhalten Sie aufgrund des Überlaufs einen falschen Wert.

Wenn es überläuft, kehrt es zum Mindestwert zurück und fährt von dort fort. Wenn es unterläuft, kehrt es zum Maximalwert zurück und fährt von dort fort.

Weitere Infos

Bearbeiten .

Lassen Sie uns Ihren Code wie folgt ändern

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

Ausgabe:

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
quelle
22

Es ist wegen eines ganzzahligen Überlaufs. Wenn Sie viele gerade Zahlen miteinander multiplizieren, erhält die Binärzahl viele nachgestellte Nullen. Wenn Sie mehr als 32 nachgestellte Nullen für ein haben int, wird ein Rollover auf ausgeführt 0.

Um Ihnen dies zu veranschaulichen, finden Sie hier die Multiplikationen in Hex, die für einen Zahlentyp berechnet wurden, der nicht überläuft. Sehen Sie, wie die nachfolgenden Nullen langsam wachsen, und beachten Sie, dass an intaus den letzten 8 Hex-Ziffern besteht. Nach dem Multiplizieren mit 42 (0x2A) sind alle 32 Bits von intNullen!

                                     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.
quelle
1
Das ist etwas irreführend. Während es korrekt zeigt, warum es auf Null geht, wird jeder Wert nach der Multiplikation in einem 32-Bit-Int gehalten, daher sollte er nach jedem Schritt abgeschnitten werden. Die Art und Weise, wie Sie Ihre Antwort geschrieben haben, impliziert, dass sie erst abgeschnitten wird, wenn die for-Schleife endet. Es wäre besser, wenn Sie nur die letzten 8 Ziffern für jeden Schritt anzeigen würden.
— RyNo
@KamikazeScotsman Ich habe meine Antwort basierend auf Ihrem Vorschlag verbessert. Weniger redundante Nullen, mehr 32-Bit-Int-Sichtbarkeit.
— Tim S.
1
+1 für die
— Anzeige
14

Irgendwo in der Mitte bekommt man 0als Produkt. Ihr gesamtes Produkt ist also 0.

In deinem Fall :

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

Jedes Mal, wenn Sie den aktuellen Wert von imit der Zahl multiplizieren, die Sie 0als Ausgabe erhalten.

— TheLostMind
quelle
@ KickButtowski - Multiplizieren Sie die Zahlen. Sie werden wissen warum: P
— TheLostMind
@KickButtowski - 0 multipliziert mit einer anderen Zahl führt für immer zu 0, nachdem der Überlauf zu jedem Zeitpunkt 0 zurückgegeben hat.
— Herr Moose
Ich habe es getan, aber ich denke, Sie sollten informativer sein, damit auch andere lernen können
— Kick Buttowski
@KickButtowski - hat die Antwort aktualisiert. Überprüfen Sie den OP-Teil.
— TheLostMind
8
@KickButtowski: Das liegt daran, dass die Überlaufverpackung mit einer Zweierpotenz erfolgt. Im Wesentlichen berechnet das OP {10 x 11 x 12 x ... x 98} Modulo 2 ^ 32. Da Vielfache von 2 in diesem Produkt mehr als 32 Mal vorkommen, ist das Ergebnis Null.
— Ruakh
12

Da viele der vorhandenen Antworten auf Implementierungsdetails von Java und Debug-Ausgabe verweisen, werfen wir einen Blick auf die Mathematik hinter der binären Multiplikation, um das Warum wirklich zu beantworten.

Der Kommentar von @kasperd geht in die richtige Richtung. Angenommen, Sie multiplizieren nicht direkt mit der Zahl, sondern mit den Primfaktoren dieser Zahl. Dann haben viele Zahlen 2 als Primfaktor. In der Binärdatei entspricht dies einer Linksverschiebung. Durch Kommutativität können wir zuerst mit Primfaktoren von 2 multiplizieren. Das heißt, wir machen nur eine Linksverschiebung.

Wenn Sie sich die binären Multiplikationsregeln ansehen, ist der einzige Fall, in dem eine 1 zu einer bestimmten Ziffernposition führt, wenn beide Operandenwerte eins sind.

Der Effekt einer Linksverschiebung ist also, dass die niedrigste Bitposition einer 1 beim weiteren Multiplizieren des Ergebnisses erhöht wird.

Da die Ganzzahl nur die Bits niedrigster Ordnung enthält, werden sie alle auf 0 gesetzt, wenn der Primfaktor 2 im Ergebnis oft genug beibehalten wird.

Es ist zu beachten, dass die Zweierkomplementdarstellung für diese Analyse nicht von Interesse ist, da das Vorzeichen des Multiplikationsergebnisses unabhängig von der resultierenden Zahl berechnet werden kann. Das heißt, wenn der Wert überläuft und negativ wird, werden die Bits niedrigster Ordnung als 1 dargestellt, aber während der Multiplikation werden sie erneut als 0 behandelt.

— SpaceTrucker
quelle
7

Wenn ich diesen Code ausführe Was ich alles bekomme -

          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

Integer Overflow Ursache -

980179200 * 18 =   463356416 (should be 17643225600)

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

Produziere 0 Ursache -

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

-90194313216: 1010100000000000000000000000000000000 <- Actual
MAX_Integer :       1111111111111111111111111111111
0           :      00000000000000000000000000000000 <- 32 bit Integer
— Subhrajyoti Majumder
quelle
6

Schließlich läuft die Berechnung über, und schließlich führt dieser Überlauf zu einem Produkt von Null. das passiert wenn product == -2147483648und i == 42. Probieren Sie diesen Code aus, um ihn selbst zu überprüfen (oder führen Sie den Code hier aus ):

import java.math.BigInteger;

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

Sobald es Null ist, bleibt es natürlich Null. Hier ist ein Code, der ein genaueres Ergebnis liefert (Sie können den Code hier ausführen ):

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
quelle
Es läuft lange vor der 42. Iteration (im wahrsten Sinne des Wortes) über - mit 19 ist es bereits übergelaufen, da f (19) <f (18)
— user295691
Ja, aber der Überlauf führt oder führt erst bei der 42. Iteration zu einem Produkt von Null.
— Trevor
Ich denke, ich möchte damit sagen, dass Sie das "Warum" nicht ansprechen - warum sollte das kumulative Produkt jemals 0 passieren? Die Antwort von Tim S. gibt einen Hinweis darauf, warum, aber die eigentliche Antwort liegt in der modularen Arithmetik.
— user295691
Die Frage fragt nicht, warum das Produkt durch Null geht. Es wird gefragt, warum der Code Null erzeugt. Mit anderen Worten, ich denke, das OP interessiert sich mehr für die Dynamik der Java-Sprache als für modulare Arithmetik, aber vielleicht irre ich mich. Es wäre nicht das erste Mal, dass ich jemandes Frage falsch interpretiere.
— Trevor
Wenn dieses Programm beispielsweise das Produkt aller ungeraden Zahlen von 11 bis 99 genommen hätte, würde es nicht Null erreichen. Ihre Antwort spricht nicht wirklich an, warum dies passieren würde.
— user295691
1

Es ist ein ganzzahliger Überlauf.

Der int-Datentyp beträgt 4 Byte oder 32 Bit. Daher können Zahlen größer als 2 ^ (32 - 1) - 1 (2.147.483.647) nicht in diesem Datentyp gespeichert werden. Ihre Zahlenwerte sind falsch.

Bei sehr großen Zahlen möchten Sie die Klasse importieren und verwenden 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());

HINWEIS: Für numerische Werte, die für den Datentyp int noch zu groß sind, aber klein genug, um in 8 Bytes zu passen (absoluter Wert kleiner oder gleich 2 ^ (64 - 1) - 1), sollten Sie wahrscheinlich das longGrundelement verwenden.

Die Übungsprobleme von HackerRank (www.hackerrank.com), wie z. B. der Abschnitt zum Üben von Algorithmen ( https://www.hackerrank.com/domains/algorithms/warmup ), enthalten einige sehr gute Fragen mit einer großen Anzahl von Fragen, die eine gute Vorgehensweise enthalten Überlegen Sie, welchen Datentyp Sie verwenden möchten.

— La-comadreja
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.