Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

Python से n-वें बाइनरी स्ट्रिंग में K-वां बिट कैसे ढूंढें?

रिकर्सिव नियम S₁=0, Sᵢ=Sᵢ₋₁ + "1" + reverse(invert(Sᵢ₋₁)) से बाइनरी स्ट्रिंग बनाकर K-वां बिट ढूंढें।

एल्गोरिदम

  • अगर k=1 तो '0' रिटर्न।
  • दो ऐरे arr (0 से शुरू) और arr2 (1 से शुरू) मेंटेन करें।
  • जब तक k > len(arr): दोनों ऐरे एक्सपैंड करें: arr = arr + [1] + arr2, arr2 = arr + [0] + arr2।
  • arr[k-1] रिटर्न करें।

उदाहरण कोड


def solve(n, k):
    if k == 1:
        return str(0)
    arr = [0]
    arr2 = [1]
    while k > len(arr):
        templast = arr.copy()
        temp2last = arr2.copy()
        arr = templast + [1] + temp2last
        arr2 = templast + [0] + temp2last
    return str(arr[k-1])

# टेस्ट: n=4, k=10 -> S₄="011100110110001", 10वां बिट = 1

इनपुट/आउटपुट

इनपुट: n=4, k=10
आउटपुट: 1

  1. Python से बाइनरी ट्री में दिए गए नोड के दाएं वाले नोड को कैसे ढूंढें? Python से बाइनरी ट्री में दिए गए नोड के दाएं वाले नोड को कैसे ढूंढें?

    लेवल ऑर्डर ट्रैवर्सल (BFS) से दिए गए नोड के उसी लेवल पर दाएं पड़ोसी नोड को ढूंढें। एल्गोरिदम क्यू से BFS, लेवल दर लेवल प्रोसेस करें। प्रत्येक लेवल के नोड्स को temp लिस्ट में स्टोर करें। अगर टारगेट नोड u मिले तो उसका इंडेक्स नोट करें। अगर इंडेक्स अंतिम है तो None रिटर्न (दाएं कोई नहीं)। अन्यथा temp[

  1. - Python से पैरेंथेसिस स्ट्रिंग को बैलेंस करने के लिए मिनिमम इंसर्शन्स कैसे ढूंढें?

    स्ट्रिंग बैलेंस है अगर हर ( के लिए दो कंसेक्यूटिव )) हों। मिनिमम इंसर्शन्स (ओपनिंग/क्लोजिंग) काउंट करें। एल्गोरिदम o = अनमैच्ड ओपनिंग काउंट, ret = इंसर्शन्स काउंट। स्ट्रिंग स्कैन करें: ( मिले तो o++। ) मिले: अगर अगला भी ) है तो पेयर प्रोसेस करें (o-- या ret++ अगर o=0)। सिंगल ) मिले: ret++ और o-- या

  1. Python से बाइनरी ग्रिड में मेजर डायगोनल के ऊपर ज़ीरोज़ के लिए मिनिमम स्वैप्स कैसे ढूंढें? Python से बाइनरी ग्रिड में मेजर डायगोनल के ऊपर ज़ीरोज़ के लिए मिनिमम स्वैप्स कैसे ढूंढें?

    n×n बाइनरी मैट्रिक्स में एडजेसेंट रो स्वैप्स से मेजर डायगोनल के ऊपर सभी एलिमेंट्स 0 करने के लिए मिनिमम स्वैप्स ढूंढें। एल्गोरिदम प्रत्येक रो के लिए राइटमोस्ट 1 की पोजीशन ढूंढें → m[i] = n - j - 1 (डायगोनल से दूरी)। ग्रीडी: i=0 से n-1, ऐसी रो ढूंढें जिसका = n-i-1 हो (यानी डायगोनल के ऊपर 1 न हो)। उसे