Java neden 10 ile 99 arasındaki tüm sayıların çarpımının 0 olduğunu düşünüyor?

131

Aşağıdaki kod bloğu çıktıyı 0 olarak verir.

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

Lütfen birisi bunun neden olduğunu açıklayabilir mi?

java  integer  integer-overflow 
— Aniruddha Sarkar
kaynak
106
Büyük olasılıkla bir tamsayı taşması var.
— TheLostMind
68
Üründeki ana faktörleri göz önüne alırsanız, 2yaklaşık 90 kez görünürsünüz. Bu, sıfır dışında bir çıktı elde etmek için en az 90 bitli bir değişkene ihtiyacınız olacağı anlamına gelir. 32 ve 64 her ikisi de 90'dan küçüktür. Ana sözcüklerden daha büyük tamsayıları hesaplamak için, seçtiğiniz dilde mevcut olan büyük tamsayı sınıfını kullanmanız gerekir.
— kasperd
62
Teknik olarak, bu 10 ila 98 arasındaki sayıların ürünüdür.
— AShelly
45
Ne? Neden bu soru bir soru tekrarı olarak kapatıldı bir kopyası olarak kapatılıyor bu soruya ?
— Salman A
82
99 sorun ve 2147483648 aint 1 aldı.
— Glenatron

Yanıtlar:

425

Program her adımda şunları yapar:

          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

Bazı adımlarda çarpmanın daha küçük bir sayıya (980179200 * 18 = 463356416) veya yanlış bir işarete (213837312 * 20 = -18221056) neden olduğunu ve tamsayı taşması olduğunu unutmayın. Fakat sıfır nereden geliyor? Okumaya devam etmek.

intVeri türünün 32 bit imzalı , ikisinin tamamlayıcı tamsayı olduğunu göz önünde bulundurarak , her adımın bir açıklaması aşağıdadır:

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. olduğu doğru sonuç
  2. sonucun dahili gösterimidir (gösterim için 64 bit kullanılır)
  3. ikisinin alt 32 biti tamamlayıcısı ile temsil edilen sonuçtur

Bir sayıyı çift sayıyla çarpmanın şunu biliyoruz:

  • bitleri sola kaydırır ve sağa sıfır bit ekler
  • çift ​​sayı ile sonuçlanır

Temel olarak programınız çift sayıyı tekrar tekrar başka bir sayıyla çarparak sağdan başlayarak sonuç bitlerini sıfırlar.

PS: Çarpmalar sadece tek sayılar içeriyorsa sonuç sıfır olmaz.

— Salman A
kaynak
15
Onaltılı Temsil, burada olup bitenler hakkında kafamı bulmama yardımcı olan şeydi. Açıkladığınız için teşekkürler!
1
Evet, programınızı uzun listedeki onaltılık değerleri de yazdıracak şekilde değiştirirseniz daha öğretici olur.
— Hot Licks
4
Bu cevap doğru ama çok fazla karmaşa var. Son beş çizgi onun kalbidir ve hiçbir yerde bunun tam olarak nasıl oynandığını göstermez. (Ama bunu dev masadan çıkarabiliriz.)
— Rex Kerr
6
Başka bir deyişle, 2 faktörünü biriktirirsiniz. Bazı sayılar size 12, 16 ve 20 gibi kendi başınıza 2'nin birden çok faktörünü verir. 2'nin her faktörü, sonraki sonuçlarınızın tüm bitlerini sağa kaydırır ve sıfıra tutucuları. 32 kez sağa kaydırdığınızda, 32 yer tutucu sıfırdan başka bir şey kalmaz.
— Keen
2
Benzer bir etki taban 10'da da görülebilir. Herhangi bir ardışık tamsayı serisini çarpmayı deneyin, her 10 ile bölünebilen bir sayı ile çarptığınızda, ürünün sonuna en az bir sıfır eklersiniz ve bu sıfırı kaldırmak imkansızdır. tamsayıların çarpımı ile üründen Bir noktada, tüm n-en az önemli basamaklar sıfırlarla doldurulur ve aritmetiği 10 ** m'lik bir modülo yapıyorsanız (m-en az önemli basamaklar hariç her şeyi kesme etkisi vardır), sonra sıfıra döner. Diğer bazlarla benzer şekilde.
— Yalan Ryan
70

Bilgisayar çarpma gerçekten modulo 2 ^ 32 oluyor. Çoğalmada iki taneye yetecek kadar güç biriktirdiğinizde, tüm değerler 0 olur.

Burada serideki tüm çift sayılara, sayıyı bölen maksimum ikiye ve ikinin toplam gücüne sahibiz.

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

42'ye kadar olan ürün x * 2 ^ 32 = 0'a eşittir (mod 2 ^ 32). İkisinin güçlerinin sırası Gri kodlarla (diğer şeylerin yanı sıra) ilişkilidir ve https://oeis.org/A001511 olarak görünür .

DÜZENLEME: Bu soruya diğer tepkiler eksik neden tek tamsayı sınırlı aynı program, sadece, gerçeğini göz önünde görmeye değil tüm taşan rağmen 0'a yakınsama.

— user295691
kaynak
Yaşasın! Son olarak, doğru cevap. İnsanlar bu cevabı daha fazla fark etmeli!
— Rex Kerr
Tek doğru cevap bu. Diğerleri nedenini açıklamıyor .
— Olivier Grégoire
5
@ OlivierGrégoire Ben katılmıyorum; Kabul edilen cevabın doğru olduğunu ve mükemmel bir açıklama verdiğini düşünüyorum. Bu daha doğrudan.
— David Z
1
Umarım daha fazla insan bu yanıtı görür. Temel neden burada belirtilmiştir!
— lanpa
1
@DavidZ: Kabul edildi; kabul edilen cevap çoğunlukla doğrudur - yazım, açılış cezamın "nedenine" gerçekten değinmez. Ancak kabul edilen yanıtın yakınlığı, "neden sıfır" cevabına en yakın şeydir, ancak "neden 42" yi açıklamaz - 10 ile 42 arasında sadece 16 çift sayı vardır
— user295691
34

Tamsayı taşması gibi görünüyor .

Şuna bir bak

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

Çıktı:

25977982938941930515945176761070443325092850981258133993315252362474391176210383043658995147728530422794328291965962468114563072000000000000000000000

Çıktı artık bir intdeğer değil. Sonra taşma nedeniyle yanlış değer elde edersiniz.

Taşarsa, minimum değere geri döner ve oradan devam eder. Taşarsa, maksimum değere geri döner ve oradan devam eder.

Daha fazla bilgi

Düzenle .

Kodunuzu aşağıdaki gibi değiştirelim

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

Çıktı:

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

Tamsayı taşması yüzünden. Çok sayıda çift sayıyı bir araya getirdiğinizde, ikili sayı çok sayıda sıfır alır. 32'nin üzerinde sıfırdan fazla sıfır intvarsa, yuvarlanır 0.

Bunu görselleştirmenize yardımcı olmak için, taşmayan bir sayı türünde hesaplanan onaltılık çarpımlar. Sondaki sıfırların yavaşça nasıl büyüdüğünü görün ve a'nın intson 8 onaltılık haneden oluştuğunu unutmayın . 42 (0x2A) ile çarpıldıktan sonra, andaki 32 bitin tümü sıfırdır int!

                                     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.
kaynak
1
Bu biraz yanıltıcı. Neden sıfıra gittiğini doğru göstermesine rağmen, her değer çarpma işleminden sonra 32 bit int'de tutulur, bu nedenle her adımdan sonra kesilmelidir. Cevabınızı yazma şekliniz, for döngüsü sona erene kadar kısaltılmayacağı anlamına gelir. Her adım için yalnızca son 8 haneyi göstermeniz daha iyi olur.
— RyNo
@KamikazeScotsman Cevabınızı önerinizi temel alarak geliştirdim. Daha az yedek sıfır, daha fazla 32 bit int görünürlük.
— Tim S.
1
Her aşamada gerçek değeri 32 bit değerine göre göstermek için +1, değerin kesildiğini vurgulamak için ...
— kwah
14

Ortada bir yerde 0ürün olarak alıyorsunuz . Yani, tüm ürününüz 0 olacaktır.

Senin durumunda :

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

Geçerli değerini her çıkış olarak ialdığınız sayıyla çarptığınızda 0.

— TheLostMind
kaynak
@KickButtowski - Sayıları çarpın .. Nedenini bileceksiniz: P
— TheLostMind
@KickButtowski - 0 herhangi bir sayı ile çarpıldığında taşma herhangi bir noktada 0 döndükten sonra sürekli olarak 0 ile sonuçlanır.
— Bay Moose
Ben yaptım ama diğer çok öğrenebilir böylece daha bilgilendirici olması gerektiğini düşünüyorum
— Kick Buttowski
@KickButtowski - yanıtı güncelledi. OP bölümünü kontrol edin.
— TheLostMind
8
@KickButtowski: Çünkü taşma sarımı iki güçte gerçekleşiyor. Esasen, OP {10 x 11 x 12 x ... x 98} modulo 2 ^ 32'yi hesaplamaktadır. Bu üründe 2'nin katları 32 kereden fazla göründüğü için sonuç sıfırdır.
— ruakh
12

Mevcut yanıtların çoğu Java ve hata ayıklama çıktısının uygulama ayrıntılarına işaret ettiğinden, nedenini gerçekten cevaplamak için ikili çarpmanın arkasındaki matematiğe bakalım.

@Kasperd'in yorumu doğru yönde. Doğrudan sayıyla değil, bu sayının asal faktörleriyle çarptığınızı varsayalım. Çok sayıda sayı asal faktör olarak 2 olacaktır. İkili dosyada bu, sola kaydırmaya eşittir. Değişebilirlik ile önce 2'nin asal faktörleri ile çarpabiliriz. Bu, sadece sola kaydırma yaptığımız anlamına gelir.

İkili çarpma kurallarına bakarken, 1'in belirli bir basamak konumuna neden olacağı tek durum, her iki işlenen değerinin de bir olmasıdır.

Bu nedenle, bir sola kaymanın etkisi, sonucu daha da çoğaltırken 1'in en düşük bit konumunun arttırılmasıdır.

Tamsayı yalnızca en düşük dereceli bitleri içerdiğinden, sonuç 2'de ana faktör 2 sık sık birleştirildiğinde hepsi 0'a ayarlanacaktır.

Çarpma sonucunun işareti, elde edilen sayıdan bağımsız olarak hesaplanabileceğinden, ikisinin tamamlayıcı gösteriminin bu analiz için ilgi çekici olmadığını unutmayın. Bu, değer taşarsa ve negatif olursa, en düşük dereceli bitler 1 olarak temsil edilir, ancak çarpma sırasında tekrar 0 olarak kabul edilir.

— SpaceTrucker
kaynak
7

Bu kodu çalıştırırsam Ne alırım -

          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

Tamsayı Taşması nedeni -

980179200 * 18 =   463356416 (should be 17643225600)

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

0 sebep üret -

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

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

Sonunda, hesaplama taşar ve sonunda taşma sıfır ürüne yol açar; o zaman olur product == -2147483648ve i == 42. Kendiniz doğrulamak için bu kodu deneyin (veya kodu burada çalıştırın ):

import java.math.BigInteger;

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

Sıfır olduğunda, elbette sıfır kalır. Daha doğru bir sonuç verecek bazı kodlar (kodu buradan çalıştırabilirsiniz ):

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
kaynak
42. yinelemeden çok önce (kelimenin tam anlamıyla) taşar - 19'da zaten taşmış, çünkü f (19) <f (18)
— user295691 15:14
Evet, ancak taşma 42. yinelemeye kadar sıfır ürünle sonuçlanmaz.
— Trevor
Sanırım ne alıyorum "neden" hitap etmiyorum - kümülatif ürün neden hiç 0 geçiyor? Tim S.'nin cevabı nedenini gösteriyor, ancak asıl cevap modüler aritmetikte yatıyor.
— user295691
Soru, ürünün neden sıfırdan geçtiğini sormuyor. Kodun neden sıfır ürettiğini sorar. Başka bir deyişle, OP'nin Java dilinin dinamikleriyle modüler aritmetikten daha fazla ilgilendiğini düşünüyorum, ama belki de yanılıyorum. Birinin sorusunu ilk kez yanlış yorumlamam.
— Trevor
bu program 99 11'den tüm tek sayının çarpımını almıştı örneğin, o zaman olurdu değil sıfır ulaşır. Cevabınız bunun neden olabileceğini gerçekten ele almıyor.
— user295691
1

Tamsayı taşmasıdır.

İnt veri türü 4 bayt veya 32 bittir. Bu nedenle, 2 ^ (32-1) - 1'den (2.147.483.647) büyük sayılar bu veri türünde saklanamaz. Sayısal değerleriniz yanlış olacaktır.

Çok büyük sayılar için sınıfı içe aktarmak ve kullanmak isteyeceksiniz 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());

NOT: int veri türü için hala çok büyük, ancak 8 bayta sığacak kadar küçük (mutlak değer 2 ^ (64 - 1) - 1'e eşit veya daha küçük) sayısal değerler için, muhtemelen longilkel olanı kullanmalısınız .

HackerRank'ın Algoritmalar uygulama bölümü gibi uygulama sorunları (www.hackerrank.com) ( https://www.hackerrank.com/domains/algorithms/warmup ), Kullanılacak uygun veri türünü düşünün.

— La-comadreja
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.