रिवर्स इंटीजर (लीटकोड)

आपकी समस्या यह है कि अतिप्रवाह num चर में है और आप इसकी जांच नहीं कर रहे हैं। यह सुनिश्चित करने के लिए एक चेक जोड़कर कि num = num*10+a करने से पहले गणना अतिप्रवाह नहीं होगी, आप आवश्यक होने पर 0 वापस कर सकते हैं।

साथ ही, आप नेगेटिव नंबरों को ठीक से हैंडल नहीं कर रहे थे। एक नकारात्मक अग्रिम के लिए एक चेक आपको एक सकारात्मक संख्या के साथ काम करने की अनुमति दे सकता है और फिर परिणाम को नकार सकता है।

class Solution {  
    public int reverse(int x) {  
        int num=0;  
        Boolean negative = false;
        
        if (x < 0) {
            x = -x;
            negative = true;
        }
        while(x!=0){  
            int a=x%10; 
            // Check if the next operation is going to cause an overflow
            // and return 0 if it does
            if (num > (Integer.MAX_VALUE-a)/10) return 0;
            num=num*10+a;  
            x=x/10;  
        }  
        return negative ? -num : num;  
    }  
} 

आपने जो तरीका चुना है, वह ज्यादा दूर नहीं है।

1. आप वर्तमान में इनपुट x को अहस्ताक्षरित पूर्णांक की सीमा में होने की जांच करते हैं। लेकिन वे इसके बजाय एक्स-रिवर्स की जांच करने के लिए कहते हैं।
2. आप अपने उत्तर को एक पूर्णांक में जोड़ते हैं, इसलिए आप किसी का ध्यान नहीं जा सकते।

आपकी दोनों समस्याओं का समाधान किया जा सकता है यदि आप अपने परिणाम num को लंबे प्रकार के एक चर में जोड़ते हैं और उत्तर को अस्वीकार/शून्य करते हैं यदि इसे उलटने के बाद अहस्ताक्षरित int की सीमा से बाहर है।

वैकल्पिक रूप से आप अतिप्रवाह पर तुरंत बाहर निकलने के लिए Math.addExact(a, b), Math.multiplyExact(a,b) और एक कोशिश-पकड़ का उपयोग कर सकते हैं।

इनपुट: 123 आउटपुट: 321 इनपुट: -123 आउटपुट: -321 इनपुट: 120 आउटपुट: 2

क्लास सॉल्यूशन { पब्लिक: इंट रिवर्स (इंट एक्स) {

    int rev = 0;

    constexpr int top_limit = INT_MAX/10;

    constexpr int bottom_limit = INT_MIN/10;

    while (x) {

        if (rev > top_limit || rev < bottom_limit)

            return 0;

        rev = rev * 10 + x % 10;

        x /= 10;
    }
    return rev;
}

};

आप सैद्धांतिक रूप से हस्ताक्षरित 32-बिट पूर्णांक अतिप्रवाह से निपट नहीं रहे हैं जो लूप में हो सकता है, जिसका अर्थ है कि आप कभी-कभी उस सीमा के बाहर एक संख्या वापस कर देंगे। साथ ही, तर्क नकारात्मक मानों के साथ अपेक्षानुसार काम नहीं करेगा।

³¹

class Solution {
    public int reverse(int x) {
        if (x < 0) return x == -2147483648 ? 0 : -reverse(-x);
        int res = 0;
        while (x > 0 && res < 214748364) {
            res = res * 10 + x % 10;
            x /= 10;
        }
        // Deal with the final digit separately to detect overflow.
        if (x > 0) {
            if (res > 214748364 || x > 7) return 0;
            return res * 10 + x;
        }
        return res;
    }
}