मैं leetcode पर 7.Reverse Integer को हल करने का प्रयास कर रहा था https://leetcode.com/problems/reverse- पूर्णांक/.

एक हस्ताक्षरित 32-बिट पूर्णांक x को देखते हुए, x को उसके अंकों को उलट कर लौटाएं। यदि x को उलटने से मान हस्ताक्षरित 32-बिट पूर्णांक श्रेणी [-2^31, 2^31 - 1] से बाहर जाता है, तो 0 लौटाएं।

उदाहरण 1:

Input: x = 123  
Output: 321

उपरोक्त समस्या का मेरा समाधान है

class Solution {  
    public int reverse(int x) {  
        int num=0;  
        if(x>Integer.MAX_VALUE||x<Integer.MIN_VALUE) return 0;  
        while(x!=0){  
            int a=x%10;  
            num=num*10+a;  
            x=x/10;  
            
            
        }  
        return num;  
    }  
}  

मुझे 4 टेस्ट केस गलत मिल रहे हैं। जिनमें से एक है:

उदाहरण

Input: 1534236469  
Output : 1056389759  
Expected: 0  
0
Rohan Sharma 15 जिंदा 2022, 17:04
आपको पूर्णांक अतिप्रवाह और इससे बचने के तरीके के बारे में सोचने की आवश्यकता है। 0 का अपेक्षित उत्तर आपको बताता है कि एक साधारण उत्क्रमण सीमा से बाहर हो जाता है।
 – 
rossum
15 जिंदा 2022, 17:21
"यदि x को उलटने से मान हस्ताक्षरित 32-बिट पूर्णांक श्रेणी [-2^31, 2^31 - 1] से बाहर जाता है, तो 0 लौटाएं।"
 – 
Johannes Kuhn
15 जिंदा 2022, 19:56
शायद वही समस्या रिवर्स इंटीजर लेटकोड - ओवरफ्लो समस्या के बारे में बताएं या यह रिवर्स इंटीजर लेटकोड - ओवरफ्लो को कैसे हैंडल करें... नहीं, यह था कैसे करें जावा रिवर्स इंटीजर लेटकोड समस्या को हल करें (यहां तक ​​कि एक ही त्रुटि) अधिक... या > ... और अभी भी कुछ और, लेकिन टिप्पणी की सीमा लगभग पूरी हो चुकी है
 – 
user16320675
15 जिंदा 2022, 20:46

4 जवाब

आपकी समस्या यह है कि अतिप्रवाह 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
vacawama 15 जिंदा 2022, 17:39

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

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

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

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

0
Vala. D. 15 जिंदा 2022, 17:23

इनपुट: 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;
}

};

0
Janith Rathnayaka 15 जिंदा 2022, 17:48
एक अच्छे उत्तर में हमेशा एक स्पष्टीकरण शामिल होगा कि यह इस मुद्दे को क्यों हल करेगा, ताकि ओपी और भविष्य के पाठक इससे सीख सकें।
 – 
Tyler2P
15 जिंदा 2022, 18:38

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

31

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;
    }
}
0
trincot 15 जिंदा 2022, 23:26