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

Python में जांचें कि टुकड़ों से सरणी बन सकती है या नहीं

मान लीजिए हमारे पास एक सरणी nums है जहां सभी तत्व यूनिक हैं और अलग-अलग छोटी सरणियों वाली एक और सरणी pieces है। हमें जांचना है कि क्या हम pieces में सरणियों को किसी भी क्रम में जोड़कर मुख्य सरणी nums प्राप्त कर सकते हैं या नहीं। लेकिन हमें pieces[i] में मौजूद तत्वों को पुनः क्रमबद्ध करने की अनुमति नहीं है।

इसलिए, यदि इनपुट है: nums = [5,1,12,36,2,47,6], pieces = [[2,47,6],[12,36],[1],[5]], तो आउटपुट True होगा क्योंकि हम उन्हें इस क्रम में जोड़ सकते हैं [[5], [1], [12,36], [2,47,6]] मुख्य सरणी प्राप्त करने के लिए।

हल करने के चरण

  • temp := एक नई सूची
  • pieces में प्रत्येक p के लिए:
    • यदि p[0], nums में मौजूद नहीं है, तो false वापस करें
    • l := p का आकार
    • indx := nums में p[0] का इंडेक्स
    • यदि nums का सबएरे इंडेक्स indx से indx+l-1 तक, p के समान नहीं है, तो false वापस करें
    • अन्यथा, p को temp के बाद जोड़ें
  • यदि nums का आकार, temp के आकार के समान है, तो true वापस करें
  • अन्यथा, false वापस करें

उदाहरण (Python)

def solve(nums, pieces):
    temp = []
    for p in pieces:
        if p[0] not in nums:
            return False
        l = len(p)
        indx = nums.index(p[0])
        if nums[indx:indx+l] != p:
            return False
        else:
            temp.extend(p)
    if len(nums) == len(temp):
        return True
    else:
        return False

nums = [5, 1, 12, 36, 2, 47, 6]
pieces = [[2, 47, 6], [12, 36], [1], [5]]
print(solve(nums, pieces))

इनपुट

[5,1,12,36,2,47,6], [[2,47,6],[12,36],[1],[5]]

आउटपुट

True
  1. - पायथन में जांचें कि क्या इंडेक्स 0 से अंतिम पोजीशन तक पहुंचा जा सकता है

    मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है जहां प्रत्येक संख्या अधिकतम कूद की संख्या दर्शाती है; हमें जांचना है कि क्या हम इंडेक्स 0 से शुरू करके अंतिम इंडेक्स तक पहुंच सकते हैं या नहीं। उदाहरण के लिए, यदि इनपुट nums = [2,5,0,2,0] है, तो आउटपुट True होगा, क्योंकि हम इंडेक्स 0 से 1 तक कूद स

  1. - पायथन में जांचें कि क्या हम बाएं या दाएं छोर तक पहुंच सकते हैं

    मान लीजिए हमारे पास तीन प्रकार के अक्षरों वाली एक स्ट्रिंग है: R, B, और डॉट (.)। यहां R हमारी वर्तमान स्थिति को दर्शाता है, B एक अवरुद्ध स्थिति को दर्शाता है, और डॉट (.) एक खाली स्थिति को दर्शाता है। अब, एक चरण में, हम अपनी वर्तमान स्थिति से किसी भी आसन्न स्थिति पर जा सकते हैं, जब तक कि वह वैध (खाली

  1. - पायथन में जांचने का प्रोग्राम कि क्या किसी शहर से किसी अन्य शहर तक जाया जा सकता है

    मान लीजिए हमारे पास n शहर हैं जिन्हें रेंज [0, n) में संख्या के रूप में दर्शाया गया है और हमारे पास एकतरफा सड़कों की एक सूची है जो एक शहर को दूसरे से जोड़ती है। हमें जांचना है कि क्या हम किसी शहर से किसी अन्य शहर तक पहुंच सकते हैं। उदाहरण के लिए, यदि इनपुट n = 3, roads = [[0,1],[0,2],[1,0],[1,2],[2