प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

32-बिट् हस्ताक्षरितं पूर्णाङ्कं x दत्त्वा x इत्यस्य संख्यात्मकं भागं विपर्ययस्य परिणामं प्रत्यागच्छतु ।

यदि विपर्यस्तपूर्णाङ्कः ३२-बिट्-हस्ताक्षरितस्य पूर्णाङ्कस्य [−२ ^३१, २ ^३१ − १] परिधिं अतिक्रमति तर्हि ० प्रत्यागच्छति ।

कल्पयतु यत् वातावरणं 64-बिट् पूर्णाङ्कानां (हस्ताक्षरितानां अहस्ताक्षरितानां वा) भण्डारणं न अनुमन्यते ।

उदाहरणम् १ : १.
निवेशः x = 123
उत्पादनम् : ३२१

उदाहरणम् २ : १.
इनपुट: x = -123
निर्गमः -321

उदाहरणम् ३ : १.
निवेशः x = 120
उत्पादनम् : 21

उदाहरणम् ४ : १.
इनपुट: x = 0
उत्पादनम् : 0

संकेत:

-2 ^31 <= x <= 2 ^31 - 1
1

एल्गोरिदम् १ (६४-बिट् पूर्णाङ्कानां संग्रहणस्य परवाहं न कृत्वा): स्ट्रिंग् फ्लिपिंग

#include <iostream>
#include <string>
#include <algorithm>
#include <climits>

class Solution {
public:
    int reverse(int x) {
        // 将整数转换为字符串
        std::string str = std::to_string(x);
        
        // 处理负号
        if (x < 0) {
            std::reverse(str.begin() + 1, str.end());
        } else {
            std::reverse(str.begin(), str.end());
        }
        
        // 将反转后的字符串转换回整数
        long rev = std::stoll(str);
        
        // 检查是否超出32位有符号整数范围
        if (rev > INT_MAX || rev < INT_MIN) {
            return 0;
        }
        
        return static_cast<int>(rev);
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

६४-बिट् पूर्णाङ्काः संग्रहीतुं न शक्यन्ते इति स्थितिः न विचारयितुं तुल्यकालिकरूपेण सरलम् अस्ति, अतः अहं विस्तरेण न गमिष्यामि ।

एल्गोरिदम 2: गणितीय पद्धति

सम्पूर्णः कोडः यथा अस्ति ।

class Solution {
public:
    int reverse(int x) {
        int max = 2147483647;
        int min = -2147483648;
        int rev = 0;
        while(x != 0){
            if(rev > max / 10 || rev < min / 10){
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev  = rev * 10 + digit;
            
        }
        return rev;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

पार्से
प्रथमं सोपानं आकारं पलटयितुं भवति :

// 弹出 x 的末尾数字 digit
digit = x % 10
x /= 10

// 将数字 digit 推入 rev 末尾
rev = rev * 10 + digit
1
2
3
4
5
6

यतो हि x ३२-बिट् पूर्णाङ्कः अस्ति, अतः अतिप्रवाहं परिहरितुं, rev अन्तिमवारं कृते।

यतः प्रश्ने अपेक्षा अस्ति यत् वातावरणं ६४-बिट् पूर्णाङ्कान् संग्रहीतुं न शक्नोति, तस्मात् प्रत्यक्षतया न भवितुम् अर्हति−2 ^ 31 ≤ rev⋅10+digit ≤2 ^ 31 −1。
अतः गणनाप्रक्रियायाः समये ३२-बिट् पूर्णाङ्काधिकाः मूल्यानि न दृश्यन्ते इति निवारयितुं केचन गणितीयविधयः स्वीकर्तुं आवश्यकाः सन्ति । अत्र सीमामूल्यानि विघटितुं शक्यन्ते । स्मरतु:

min = −2 ^31 = -2147483648;
max = 2 ^31−1 = 2147483647;
1
2

तस्य भङ्गाय : १.
मि = (मिनट/१०) * १० - ८;
अधिकतम = (अधिकतम / 10) * 10 + 7;

यदा x>0, .
rev * 10 + अङ्क <= (अधिकतम/10) * 10 + 7
=>
(rev - max/10)*10 <= 7 - अंक;

यदा rev < max/10:
अर्थात् यदा अङ्कः <= 17. अङ्कः <= 9 इति कारणतः समीकरणं सर्वदा धारयति।

यदा rev = अधिकतम/10:
अङ्क <= 7;
यदि अस्मिन् समये x इत्यस्य विच्छेदनं कर्तुं शक्यते तर्हि x इत्यस्मिन् अङ्कानां संख्या max इत्यस्य समाना अस्ति, अस्मिन् समये च अङ्कः x इत्यस्य उच्चतमः अङ्कः अस्ति, तथा च यतो हि x <= 2 ^31 - 1 = 2147483647, x इत्यस्य उच्चतमः अङ्कः 2. अर्थात् अङ्कः<=2, अतः समीकरणं सर्वदा धारयति।

यदा rev > max/10:
अस्मिन् समये विश्लेषणं x>0 इति स्थितिः इति कारणतः एषा स्थितिः न धारयति ।

अतः x <= max/10 इति सरलं कर्तुं शक्यते, अतः कोड् मध्ये, यदा x>max/10, तदा भवान् 0 प्रत्यागन्तुं शक्नोति;

---

तदनन्तरं x<0 इति स्थितिः तथैव विश्लेषितुं शक्यते ।