पूर्णांक N को देखते हुए। N से छोटा सबसे बड़ा पूर्णांक क्या है, जिसके अंक केवल 0 या 1 हैं?

Question

मेरे पास एक पूर्णांक N है। मुझे N की तुलना में सबसे छोटा पूर्णांक N = 12ज्ञात करना है जिसमें 0 या 1. के अलावा कोई अंक नहीं है। उदाहरण के लिए: यदि उत्तर है तो 100। मैंने C ++ में एक क्रूर बल दृष्टिकोण को कोडित किया है।

int main() {
    long long n;
    cin >> n;

    for (long long i = n + 1; ; i++) {
        long long temp = i;
        bool ok = true;
        while (temp != 0) {
            if ( (temp % 10) != 0 && (temp % 10) != 1) {
                ok = false;
                break;
            }
            temp /= 10;
        }
        if (ok == true) {
            cout << i << endl;
            break;
        }
    }
}

समस्या यह है, मेरा दृष्टिकोण बहुत धीमा है। मेरा मानना ​​है कि इसे हल करने के लिए एक बहुत ही कुशल दृष्टिकोण है। मैं इस समस्या को कुशलता से कैसे हल कर सकता हूं?

Comments

इकाइयों से शुरू करें। यदि अंक 0 या 1 के अलावा अन्य है तो एक शून्य डालें और ले जाएं 1. प्रत्येक स्थिति के लिए दोहराएं

— सेम्बी नोरिमकी

यह एक समान समस्या का वर्णन करता है। शायद मदद करता है

— टॉमबॉम्बेडिल

क्या नकारात्मक Nअनुमति है? इसके अलावा, यह मुश्किल है क्योंकि आप अपने प्रकार से बहने का जोखिम उठाते हैं। सीमा क्या हैं N?

— बाथशीबा

@SembeiNorimaki: यह गलत है। यह 0 और 1. से बना एक नंबर अपरिवर्तित छोड़ देगा और अन्य विफलताएं हैं।

— यवेस डाएव

@SembeiNorimaki: मैंने कहा कि अन्य विफलताएं हैं। वे रहते हैं, क्योंकि आपका तरीका गलत है। पूर्णांक 1 से 50 तक की कोशिश करें और आपको गलतियां मिलेंगी। एराएरे ह्यूमनम, डायबोरोमम को जारी रखें।

— यवेस डाएव

Answer 1

1. वृद्धि एन,

2. बाईं ओर से शुरू करें, तब तक स्कैन करें जब तक कि आप ऊपर एक अंक न मिलें। इससे पहले कि आंशिक संख्या बढ़ाएँ और बाकी को शून्य कर दें।

उदाहरण के लिए

12 -> 13 -> 1|3 -> 10|0
101 -> 102 -> 10|2 -> 11|0
109 -> 110 -> 110|
111 -> 112 -> 11|2 -> 100|0
198 -> 199 -> 1|99 -> 10|00
1098 -> 1099 -> 10|99 -> 11|00
10203 -> 10204 -> 10|204 -> 11|000
111234 -> 111235 -> 111|235 -> 1000|000
...

---

सबूत:

अनुरोधित संख्या कम से कम N + 1 होनी चाहिए, यही कारण है कि हम वेतन वृद्धि करते हैं। हम अब अधिक या समान संख्या की तलाश कर रहे हैं।

आइए हम उपसर्ग को प्रारंभिक 0/1 अंक कहते हैं और उसके बाद आने वाले प्रत्यय को कहते हैं। हमें प्रत्यय के पहले अंक को एक शून्य से बदलना होगा और एक बड़ा उपसर्ग सेट करना होगा। सबसे छोटा उपसर्ग जो फिट बैठता है वह वर्तमान उपसर्ग प्लस एक है। और जो सबसे छोटा प्रत्यय है वह सभी शून्य है।

---

अपडेट करें:

मैं यह बताना भूल गया कि उपसर्ग को द्विआधारी संख्या के रूप में बढ़ाया जाना चाहिए , अन्यथा निषिद्ध अंक दिखाई दे सकते हैं।

Answer 2

एक और संभावना निम्नलिखित होगी:

• आप उपयोग किए गए डेटा प्रकार द्वारा समर्थित "1111111 ... 1111" प्रकार की सबसे बड़ी दशमलव संख्या से शुरू करते हैं

  एल्गोरिथ्म मानता है कि इनपुट इस संख्या से छोटा है; अन्यथा आपको दूसरे डेटा प्रकार का उपयोग करना होगा।

  उदाहरण: उपयोग करते समय long long, आप संख्या के साथ शुरू करते हैं 1111111111111111111।

• फिर बाएं से दाएं प्रत्येक दशमलव अंक को संसाधित करें:
  • अंक को 1 से 0 तक बदलने का प्रयास करें।
  • यदि परिणाम आपके इनपुट से अभी भी बड़ा है, तो परिवर्तन करें (अंक को 0 पर बदलें)।
  • अन्यथा अंक 1 रहता है।

उदाहरण

Input = 10103
Start:  111111
Step 1: [1]11111, try [0]11111; 011111 > 10103 => 011111 
Step 2: 0[1]1111, try 0[0]1111; 001111 < 10103 => 011111
Step 3: 01[1]111, try 01[0]111; 010111 > 10103 => 010111
Step 4: 010[1]11, try 010[0]11; 010011 < 10103 => 010111
Step 5: 0101[1]1, try 0101[0]1; 010101 < 10103 => 010111
Step 6: 01011[1], try 01011[0]; 010110 > 10103 => 010110
Result: 010110

शुद्धता का प्रमाण:

हम इस एल्गोरिथ्म में अंकों द्वारा अंकों की प्रक्रिया करते हैं। प्रत्येक चरण में, ऐसे अंक होते हैं जिनका मूल्य पहले से ज्ञात होता है और ऐसे अंक जिनके मान ज्ञात नहीं हैं, फिर भी।

प्रत्येक चरण में, हम बाईं ओर के अज्ञात अंक की जांच करते हैं।

हम उस अंक को "0" और अन्य सभी अज्ञात अंकों को "1" पर सेट करते हैं। क्योंकि अंको की जांच की जाने वाली संख्या अज्ञात अंकों की सबसे महत्वपूर्ण होती है, जिसके परिणामस्वरूप संख्या उस अंक का सबसे बड़ा संभव अंक होता है जिसमें "0" होता है। यदि यह संख्या इनपुट से कम या बराबर है, तो जांच की जा रही अंक "1" होना चाहिए।

दूसरी ओर, परिणामी संख्या सभी संभावित संख्याओं की तुलना में छोटी होती है जहां अंक की जांच की जा रही है "1"। यदि परिणामी संख्या इनपुट से बड़ी है, तो अंक "0" होना चाहिए।

इसका मतलब है कि हम प्रत्येक चरण में एक अंक की गणना कर सकते हैं।

सी कोड

(C कोड C ++ के अंतर्गत भी काम करना चाहिए):

long long input;
long long result;
long long digit;

... read in input ...

result = 1111111111111111111ll;
digit = 1000000000000000000ll;

while( digit > 0 )
{
    if(result - digit > input)
    {
        result -= digit;
    }
    digit /= 10;
}

... print out output ...

Answer 3

मुझे कुछ विकल्पों का सुझाव दें।

I. वेतन वृद्धि। इसे @YvesDaoust विधि के संशोधन पर विचार करें।

1. 1 से N बढ़ाएं
2. अग्रणी शून्य के साथ परिणाम का विस्तार करें
3. पिछले से दूसरे अंक
   (ए) पर जाएं यदि यह 2 से कम है तो जैसा है सब कुछ छोड़ दें
   (b) अन्यथा इसे 0 पर सेट करें और पूर्ववर्ती वृद्धि करें
4. दोहराएँ चरण 3 ए, बी

उदाहरण:

1. N = 0 -> 1 -> (0)|(1) -> 1
2. N = 1 -> 2 -> (0)|(2) -> (1)|(0) -> 10
3. N = 101 -> 102 -> (0)|(1)(0)(2) -> (0)|(1)(1)(0) -> (0)|(1)(1)(0) -> (0)|(1)(1)(0) -> 110
4. N = 298 -> 299 -> (0)|(2)(9)(9) -> (0)|(2)(10)(0) -> (0)|(3)(0)(0) -> (1)|(0)(0)(0) -> 1000

आपको दशमलव प्रारूप में परिणाम मिलता है।

---

द्वितीय। डिवाइडिंग।

1. 1 से N बढ़ाएं
2. 0 पर सेट करें
3. डिव (डी) और मॉड (एम) भागों को प्राप्त करने के लिए परिणाम को 10 से विभाजित करें
4. M
   (a) की जाँच करें यदि M 1 से अधिक है तो D
   (b) बढ़ाएं अन्यथा M * 10 ^{k से} योग बढ़ाएँ , जहाँ k वर्तमान पुनरावृत्ति संख्या है (0 से शुरू)
5. जब तक डी 0 है तब तक चरण 3,4 दोहराएं

उदाहरण 1:

1. N = 0 -> N = 1
2. sum = 0
3. 1/10 -> D == 0, M == 1 -> sum = sum + 1*10^0 == 1
4. D == 0 -> sum == 1

उदाहरण 2:

1. N = 1 -> N = 2
2. sum = 0
3. 2/10 -> D == 0, M == 2 -> D = D + 1 == 1
4. 1/10 -> D == 0, M == 1 -> sum = sum + 1*10^1 == 10
5. D == 0, sum == 10

उदाहरण 3:

1. N = 101 -> N = 102
2. sum = 0
3. 102/10 -> D == 10, M == 2 -> D = D + 1 == 11
4. 11/10 -> D == 1, M == 1 -> sum = sum + 1*10^1 = 10
5. 1/10 -> D == 0, M == 1 -> sum = sum + 1*10^2 == 10 + 100 == 110
6. D == 0, sum == 110

उदाहरण 4:

1. N = 298 -> N = 299
2. sum = 0
3. 299/10 -> D == 29, M == 9 -> D = D + 1 == 30
4. 30/10 -> D == 3, M == 0 -> sum = sum + 0*10^1 == 0
5. 3/10 -> D == 0, M == 3 -> D = D + 1
6. 1/10 -> D == 0, M == 1 -> sum = sum + 1*10^3 == 1000
7. D == 0, sum == 1000